Waves Full Node

Activation

activationStatus

Status

Get activation status


/activation/status

Usage and SDK Samples

curl -X GET "http://localhost/activation/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivationApi;

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

public class ActivationApiExample {

    public static void main(String[] args) {
        
        ActivationApi apiInstance = new ActivationApi();
        try {
            apiInstance.activationStatus();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivationApi#activationStatus");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ActivationApi;

public class ActivationApiExample {

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

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

// Status
[apiInstance activationStatusWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ActivationApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activationStatus(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class activationStatusExample
    {
        public void main()
        {
            
            var apiInstance = new ActivationApi();

            try
            {
                // Status
                apiInstance.activationStatus();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ActivationApi.activationStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ActivationApi();

try {
    $api_instance->activationStatus();
} catch (Exception $e) {
    echo 'Exception when calling ActivationApi->activationStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivationApi;

my $api_instance = WWW::SwaggerClient::ActivationApi->new();

eval { 
    $api_instance->activationStatus();
};
if ($@) {
    warn "Exception when calling ActivationApi->activationStatus: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ActivationApi()

try: 
    # Status
    api_instance.activation_status()
except ApiException as e:
    print("Exception when calling ActivationApi->activationStatus: %s\n" % e)

Parameters

Responses

Status: 200 - Json activation status


Addresses

balance

Balance

Account's balance


/addresses/balance/{address}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/balance/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balance");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Balance
[apiInstance balanceWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.balance(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class balanceExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Balance
                Function1RequestContextFutureRouteResult result = apiInstance.balance(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.balance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->balance($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->balance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->balance(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->balance: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Balance
    api_response = api_instance.balance(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->balance: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


balanceDetails

Details for balance

Account's balances


/addresses/balance/details/{address}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/balance/details/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceDetails(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balanceDetails");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceDetails(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balanceDetails");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Details for balance
[apiInstance balanceDetailsWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.balanceDetails(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class balanceDetailsExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Details for balance
                Function1RequestContextFutureRouteResult result = apiInstance.balanceDetails(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.balanceDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->balanceDetails($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->balanceDetails: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->balanceDetails(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->balanceDetails: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Details for balance
    api_response = api_instance.balance_details(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->balanceDetails: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


balanceWithConfirmations

Confirmed balance

Balance of {address} after {confirmations}


/addresses/balance/{address}/{confirmations}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/balance/{address}/{confirmations}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        Integer confirmations = 56; // Integer | 0
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceWithConfirmations(address, confirmations);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balanceWithConfirmations");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        Integer confirmations = 56; // Integer | 0
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceWithConfirmations(address, confirmations);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#balanceWithConfirmations");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address
Integer *confirmations = 56; // 0

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

// Confirmed balance
[apiInstance balanceWithConfirmationsWith:address
    confirmations:confirmations
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address

var confirmations = 56; // {Integer} 0


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.balanceWithConfirmations(address, confirmations, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class balanceWithConfirmationsExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address
            var confirmations = 56;  // Integer | 0

            try
            {
                // Confirmed balance
                Function1RequestContextFutureRouteResult result = apiInstance.balanceWithConfirmations(address, confirmations);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.balanceWithConfirmations: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address
$confirmations = 56; // Integer | 0

try {
    $result = $api_instance->balanceWithConfirmations($address, $confirmations);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->balanceWithConfirmations: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address
my $confirmations = 56; # Integer | 0

eval { 
    my $result = $api_instance->balanceWithConfirmations(address => $address, confirmations => $confirmations);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->balanceWithConfirmations: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address
confirmations = 56 # Integer | 0

try: 
    # Confirmed balance
    api_response = api_instance.balance_with_confirmations(address, confirmations)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->balanceWithConfirmations: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
confirmations*
Integer
0
Required

Responses

Status: 200 - successful operation


create

Create

Create a new account in the wallet(if it exists)


/addresses

Usage and SDK Samples

curl -X POST "http://localhost/addresses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.create();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#create");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

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

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

// Create
[apiInstance createWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.create(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();

            try
            {
                // Create
                Function1RequestContextFutureRouteResult result = apiInstance.create();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.create: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();

try {
    $result = $api_instance->create();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->create: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();

eval { 
    my $result = $api_instance->create();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->create: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()

try: 
    # Create
    api_response = api_instance.create()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->create: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


deleteAddress

Delete

Remove the account with address {address} from the wallet


/addresses/{address}

Usage and SDK Samples

curl -X DELETE "http://localhost/addresses/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.deleteAddress(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#deleteAddress");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.deleteAddress(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#deleteAddress");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Delete
[apiInstance deleteAddressWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAddress(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteAddressExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Delete
                Function1RequestContextFutureRouteResult result = apiInstance.deleteAddress(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.deleteAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->deleteAddress($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->deleteAddress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->deleteAddress(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->deleteAddress: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Delete
    api_response = api_instance.delete_address(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->deleteAddress: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


effectiveBalance

Balance

Account's balance


/addresses/effectiveBalance/{address}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/effectiveBalance/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#effectiveBalance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#effectiveBalance");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Balance
[apiInstance effectiveBalanceWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.effectiveBalance(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class effectiveBalanceExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Balance
                Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalance(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.effectiveBalance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->effectiveBalance($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->effectiveBalance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->effectiveBalance(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->effectiveBalance: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Balance
    api_response = api_instance.effective_balance(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->effectiveBalance: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


effectiveBalanceWithConfirmations

Confirmed balance

Balance of {address} after {confirmations}


/addresses/effectiveBalance/{address}/{confirmations}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/effectiveBalance/{address}/{confirmations}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        Integer confirmations = 56; // Integer | 0
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalanceWithConfirmations(address, confirmations);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#effectiveBalanceWithConfirmations");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        Integer confirmations = 56; // Integer | 0
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalanceWithConfirmations(address, confirmations);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#effectiveBalanceWithConfirmations");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address
Integer *confirmations = 56; // 0

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

// Confirmed balance
[apiInstance effectiveBalanceWithConfirmationsWith:address
    confirmations:confirmations
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address

var confirmations = 56; // {Integer} 0


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.effectiveBalanceWithConfirmations(address, confirmations, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class effectiveBalanceWithConfirmationsExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address
            var confirmations = 56;  // Integer | 0

            try
            {
                // Confirmed balance
                Function1RequestContextFutureRouteResult result = apiInstance.effectiveBalanceWithConfirmations(address, confirmations);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.effectiveBalanceWithConfirmations: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address
$confirmations = 56; // Integer | 0

try {
    $result = $api_instance->effectiveBalanceWithConfirmations($address, $confirmations);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->effectiveBalanceWithConfirmations: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address
my $confirmations = 56; # Integer | 0

eval { 
    my $result = $api_instance->effectiveBalanceWithConfirmations(address => $address, confirmations => $confirmations);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->effectiveBalanceWithConfirmations: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address
confirmations = 56 # Integer | 0

try: 
    # Confirmed balance
    api_response = api_instance.effective_balance_with_confirmations(address, confirmations)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->effectiveBalanceWithConfirmations: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
confirmations*
Integer
0
Required

Responses

Status: 200 - successful operation


publicKey

Address from Public Key

Generate a address from public key


/addresses/publicKey/{publicKey}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/publicKey/{publicKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String publicKey = publicKey_example; // String | Public key Base58-encoded
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.publicKey(publicKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#publicKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String publicKey = publicKey_example; // String | Public key Base58-encoded
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.publicKey(publicKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#publicKey");
            e.printStackTrace();
        }
    }
}
String *publicKey = publicKey_example; // Public key Base58-encoded

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

// Address from Public Key
[apiInstance publicKeyWith:publicKey
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var publicKey = publicKey_example; // {String} Public key Base58-encoded


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.publicKey(publicKey, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class publicKeyExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var publicKey = publicKey_example;  // String | Public key Base58-encoded

            try
            {
                // Address from Public Key
                Function1RequestContextFutureRouteResult result = apiInstance.publicKey(publicKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.publicKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$publicKey = publicKey_example; // String | Public key Base58-encoded

try {
    $result = $api_instance->publicKey($publicKey);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->publicKey: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $publicKey = publicKey_example; # String | Public key Base58-encoded

eval { 
    my $result = $api_instance->publicKey(publicKey => $publicKey);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->publicKey: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
publicKey = publicKey_example # String | Public key Base58-encoded

try: 
    # Address from Public Key
    api_response = api_instance.public_key(publicKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->publicKey: %s\n" % e)

Parameters

Path parameters
Name Description
publicKey*
String
Public key Base58-encoded
Required

Responses

Status: 200 - successful operation


root

Addresses

Get wallet accounts addresses


/addresses

Usage and SDK Samples

curl -X GET "http://localhost/addresses"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.root();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#root");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

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

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

// Addresses
[apiInstance rootWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.root(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class rootExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();

            try
            {
                // Addresses
                Function1RequestContextFutureRouteResult result = apiInstance.root();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.root: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();

try {
    $result = $api_instance->root();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->root: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();

eval { 
    my $result = $api_instance->root();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->root: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()

try: 
    # Addresses
    api_response = api_instance.root()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->root: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


seed

Seed

Export seed value for the {address}


/addresses/seed/{address}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/seed/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seed(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#seed");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seed(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#seed");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Seed
[apiInstance seedWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.seed(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class seedExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Seed
                Function1RequestContextFutureRouteResult result = apiInstance.seed(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.seed: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->seed($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->seed: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->seed(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->seed: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Seed
    api_response = api_instance.seed(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->seed: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


seq

Seq

Get wallet accounts addresses


/addresses/seq/{from}/{to}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/seq/{from}/{to}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        Integer from = 56; // Integer | Start address
        Integer to = 56; // Integer | address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seq(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#seq");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        Integer from = 56; // Integer | Start address
        Integer to = 56; // Integer | address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seq(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#seq");
            e.printStackTrace();
        }
    }
}
Integer *from = 56; // Start address
Integer *to = 56; // address

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

// Seq
[apiInstance seqWith:from
    to:to
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var from = 56; // {Integer} Start address

var to = 56; // {Integer} address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.seq(from, to, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class seqExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var from = 56;  // Integer | Start address
            var to = 56;  // Integer | address

            try
            {
                // Seq
                Function1RequestContextFutureRouteResult result = apiInstance.seq(from, to);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.seq: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$from = 56; // Integer | Start address
$to = 56; // Integer | address

try {
    $result = $api_instance->seq($from, $to);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->seq: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $from = 56; # Integer | Start address
my $to = 56; # Integer | address

eval { 
    my $result = $api_instance->seq(from => $from, to => $to);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->seq: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
from = 56 # Integer | Start address
to = 56 # Integer | address

try: 
    # Seq
    api_response = api_instance.seq(from, to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->seq: %s\n" % e)

Parameters

Path parameters
Name Description
from*
Integer
Start address
Required
to*
Integer
address
Required

Responses

Status: 200 - successful operation


sign

Sign

Sign a message with a private key associated with {address}


/addresses/sign/{address}

Usage and SDK Samples

curl -X POST "http://localhost/addresses/sign/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String message = message_example; // String | Message to sign as a plain string
        String address = address_example; // String | Address
        try {
            apiInstance.sign(message, address);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#sign");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String message = message_example; // String | Message to sign as a plain string
        String address = address_example; // String | Address
        try {
            apiInstance.sign(message, address);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#sign");
            e.printStackTrace();
        }
    }
}
String *message = message_example; // Message to sign as a plain string
String *address = address_example; // Address

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

// Sign
[apiInstance signWith:message
    address:address
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var message = message_example; // {String} Message to sign as a plain string

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.sign(message, address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class signExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var message = message_example;  // String | Message to sign as a plain string
            var address = address_example;  // String | Address

            try
            {
                // Sign
                apiInstance.sign(message, address);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.sign: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$message = message_example; // String | Message to sign as a plain string
$address = address_example; // String | Address

try {
    $api_instance->sign($message, $address);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->sign: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $message = WWW::SwaggerClient::Object::String->new(); # String | Message to sign as a plain string
my $address = address_example; # String | Address

eval { 
    $api_instance->sign(message => $message, address => $address);
};
if ($@) {
    warn "Exception when calling AddressesApi->sign: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
message = message_example # String | Message to sign as a plain string
address = address_example # String | Address

try: 
    # Sign
    api_instance.sign(message, address)
except ApiException as e:
    print("Exception when calling AddressesApi->sign: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
Body parameters
Name Description
message *

Responses

Status: 200 - Json with error or json like {"message": "Base58-encoded","publickey": "Base58-encoded", "signature": "Base58-encoded"}


signText

Sign

Sign a message with a private key associated with {address}


/addresses/signText/{address}

Usage and SDK Samples

curl -X POST "http://localhost/addresses/signText/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String message = message_example; // String | Message to sign as a plain string
        String address = address_example; // String | Address
        try {
            apiInstance.signText(message, address);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#signText");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String message = message_example; // String | Message to sign as a plain string
        String address = address_example; // String | Address
        try {
            apiInstance.signText(message, address);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#signText");
            e.printStackTrace();
        }
    }
}
String *message = message_example; // Message to sign as a plain string
String *address = address_example; // Address

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

// Sign
[apiInstance signTextWith:message
    address:address
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var message = message_example; // {String} Message to sign as a plain string

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.signText(message, address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class signTextExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var message = message_example;  // String | Message to sign as a plain string
            var address = address_example;  // String | Address

            try
            {
                // Sign
                apiInstance.signText(message, address);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.signText: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$message = message_example; // String | Message to sign as a plain string
$address = address_example; // String | Address

try {
    $api_instance->signText($message, $address);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->signText: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $message = WWW::SwaggerClient::Object::String->new(); # String | Message to sign as a plain string
my $address = address_example; # String | Address

eval { 
    $api_instance->signText(message => $message, address => $address);
};
if ($@) {
    warn "Exception when calling AddressesApi->signText: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
message = message_example # String | Message to sign as a plain string
address = address_example # String | Address

try: 
    # Sign
    api_instance.sign_text(message, address)
except ApiException as e:
    print("Exception when calling AddressesApi->signText: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
Body parameters
Name Description
message *

Responses

Status: 200 - Json with error or json like {"message": "plain text","publickey": "Base58-encoded", "signature": "Base58-encoded"}


validate

Validate

Check whether address {address} is valid or not


/addresses/validate/{address}

Usage and SDK Samples

curl -X GET "http://localhost/addresses/validate/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.validate(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#validate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.validate(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#validate");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Validate
[apiInstance validateWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.validate(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class validateExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address

            try
            {
                // Validate
                Function1RequestContextFutureRouteResult result = apiInstance.validate(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.validate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->validate($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->validate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->validate(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->validate: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address

try: 
    # Validate
    api_response = api_instance.validate(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->validate: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


verify

Verify

Check a signature of a message signed by an account


/addresses/verify/{address}

Usage and SDK Samples

curl -X POST "http://localhost/addresses/verify/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        SignedMessage body = ; // SignedMessage | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.verify(address, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#verify");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        SignedMessage body = ; // SignedMessage | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.verify(address, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#verify");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address
SignedMessage *body = ; // Json with data

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

// Verify
[apiInstance verifyWith:address
    body:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address

var body = ; // {SignedMessage} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.verify(address, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class verifyExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address
            var body = new SignedMessage(); // SignedMessage | Json with data

            try
            {
                // Verify
                Function1RequestContextFutureRouteResult result = apiInstance.verify(address, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.verify: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address
$body = ; // SignedMessage | Json with data

try {
    $result = $api_instance->verify($address, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->verify: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address
my $body = WWW::SwaggerClient::Object::SignedMessage->new(); # SignedMessage | Json with data

eval { 
    my $result = $api_instance->verify(address => $address, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->verify: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address
body =  # SignedMessage | Json with data

try: 
    # Verify
    api_response = api_instance.verify(address, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->verify: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


verifyText

Verify text

Check a signature of a message signed by an account


/addresses/verifyText/{address}

Usage and SDK Samples

curl -X POST "http://localhost/addresses/verifyText/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AddressesApi;

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

public class AddressesApiExample {

    public static void main(String[] args) {
        
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        SignedMessage body = ; // SignedMessage | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.verifyText(address, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#verifyText");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AddressesApi;

public class AddressesApiExample {

    public static void main(String[] args) {
        AddressesApi apiInstance = new AddressesApi();
        String address = address_example; // String | Address
        SignedMessage body = ; // SignedMessage | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.verifyText(address, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AddressesApi#verifyText");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address
SignedMessage *body = ; // Json with data

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

// Verify text
[apiInstance verifyTextWith:address
    body:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AddressesApi()

var address = address_example; // {String} Address

var body = ; // {SignedMessage} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.verifyText(address, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class verifyTextExample
    {
        public void main()
        {
            
            var apiInstance = new AddressesApi();
            var address = address_example;  // String | Address
            var body = new SignedMessage(); // SignedMessage | Json with data

            try
            {
                // Verify text
                Function1RequestContextFutureRouteResult result = apiInstance.verifyText(address, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AddressesApi.verifyText: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AddressesApi();
$address = address_example; // String | Address
$body = ; // SignedMessage | Json with data

try {
    $result = $api_instance->verifyText($address, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AddressesApi->verifyText: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AddressesApi;

my $api_instance = WWW::SwaggerClient::AddressesApi->new();
my $address = address_example; # String | Address
my $body = WWW::SwaggerClient::Object::SignedMessage->new(); # SignedMessage | Json with data

eval { 
    my $result = $api_instance->verifyText(address => $address, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AddressesApi->verifyText: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AddressesApi()
address = address_example # String | Address
body =  # SignedMessage | Json with data

try: 
    # Verify text
    api_response = api_instance.verify_text(address, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AddressesApi->verifyText: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


Alias

addressOfAlias

Account

Returns an address associated with an Alias. Alias should be plain text without an 'alias' prefix and network code.


/alias/by-alias/{alias}

Usage and SDK Samples

curl -X GET "http://localhost/alias/by-alias/{alias}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AliasApi;

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

public class AliasApiExample {

    public static void main(String[] args) {
        
        AliasApi apiInstance = new AliasApi();
        String alias = alias_example; // String | Alias
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.addressOfAlias(alias);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#addressOfAlias");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        String alias = alias_example; // String | Alias
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.addressOfAlias(alias);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#addressOfAlias");
            e.printStackTrace();
        }
    }
}
String *alias = alias_example; // Alias

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

// Account
[apiInstance addressOfAliasWith:alias
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AliasApi()

var alias = alias_example; // {String} Alias


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addressOfAlias(alias, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addressOfAliasExample
    {
        public void main()
        {
            
            var apiInstance = new AliasApi();
            var alias = alias_example;  // String | Alias

            try
            {
                // Account
                Function1RequestContextFutureRouteResult result = apiInstance.addressOfAlias(alias);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.addressOfAlias: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AliasApi();
$alias = alias_example; // String | Alias

try {
    $result = $api_instance->addressOfAlias($alias);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AliasApi->addressOfAlias: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AliasApi;

my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $alias = alias_example; # String | Alias

eval { 
    my $result = $api_instance->addressOfAlias(alias => $alias);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AliasApi->addressOfAlias: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AliasApi()
alias = alias_example # String | Alias

try: 
    # Account
    api_response = api_instance.address_of_alias(alias)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AliasApi->addressOfAlias: %s\n" % e)

Parameters

Path parameters
Name Description
alias*
String
Alias
Required

Responses

Status: 200 - successful operation


alias

Creates an alias


/alias/create

Usage and SDK Samples

curl -X POST "http://localhost/alias/create"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AliasApi;

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

public class AliasApiExample {

    public static void main(String[] args) {
        
        AliasApi apiInstance = new AliasApi();
        CreateAliasRequest body = ; // CreateAliasRequest | Json with data
        try {
            apiInstance.alias(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#alias");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        CreateAliasRequest body = ; // CreateAliasRequest | Json with data
        try {
            apiInstance.alias(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#alias");
            e.printStackTrace();
        }
    }
}
CreateAliasRequest *body = ; // Json with data

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

// Creates an alias
[apiInstance aliasWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AliasApi()

var body = ; // {CreateAliasRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.alias(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class aliasExample
    {
        public void main()
        {
            
            var apiInstance = new AliasApi();
            var body = new CreateAliasRequest(); // CreateAliasRequest | Json with data

            try
            {
                // Creates an alias
                apiInstance.alias(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.alias: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AliasApi();
$body = ; // CreateAliasRequest | Json with data

try {
    $api_instance->alias($body);
} catch (Exception $e) {
    echo 'Exception when calling AliasApi->alias: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AliasApi;

my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $body = WWW::SwaggerClient::Object::CreateAliasRequest->new(); # CreateAliasRequest | Json with data

eval { 
    $api_instance->alias(body => $body);
};
if ($@) {
    warn "Exception when calling AliasApi->alias: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AliasApi()
body =  # CreateAliasRequest | Json with data

try: 
    # Creates an alias
    api_instance.alias(body)
except ApiException as e:
    print("Exception when calling AliasApi->alias: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with response or error


aliasOfAddress

Alias

Returns a collection of aliases associated with an Address


/alias/by-address/{address}

Usage and SDK Samples

curl -X GET "http://localhost/alias/by-address/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AliasApi;

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

public class AliasApiExample {

    public static void main(String[] args) {
        
        AliasApi apiInstance = new AliasApi();
        String address = address_example; // String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.aliasOfAddress(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#aliasOfAddress");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        String address = address_example; // String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.aliasOfAddress(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#aliasOfAddress");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7

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

// Alias
[apiInstance aliasOfAddressWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AliasApi()

var address = address_example; // {String} 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aliasOfAddress(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class aliasOfAddressExample
    {
        public void main()
        {
            
            var apiInstance = new AliasApi();
            var address = address_example;  // String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7

            try
            {
                // Alias
                Function1RequestContextFutureRouteResult result = apiInstance.aliasOfAddress(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.aliasOfAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AliasApi();
$address = address_example; // String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7

try {
    $result = $api_instance->aliasOfAddress($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AliasApi->aliasOfAddress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AliasApi;

my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $address = address_example; # String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7

eval { 
    my $result = $api_instance->aliasOfAddress(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AliasApi->aliasOfAddress: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AliasApi()
address = address_example # String | 3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7

try: 
    # Alias
    api_response = api_instance.alias_of_address(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AliasApi->aliasOfAddress: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
3Mx2afTZ2KbRrLNbytyzTtXukZvqEB8SkW7
Required

Responses

Status: 200 - successful operation


signedCreate

Broadcasts a signed alias transaction


/alias/broadcast/create

Usage and SDK Samples

curl -X POST "http://localhost/alias/broadcast/create"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AliasApi;

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

public class AliasApiExample {

    public static void main(String[] args) {
        
        AliasApi apiInstance = new AliasApi();
        SignedCreateAliasRequest body = ; // SignedCreateAliasRequest | Json with data
        try {
            apiInstance.signedCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#signedCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AliasApi;

public class AliasApiExample {

    public static void main(String[] args) {
        AliasApi apiInstance = new AliasApi();
        SignedCreateAliasRequest body = ; // SignedCreateAliasRequest | Json with data
        try {
            apiInstance.signedCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AliasApi#signedCreate");
            e.printStackTrace();
        }
    }
}
SignedCreateAliasRequest *body = ; // Json with data

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

// Broadcasts a signed alias transaction
[apiInstance signedCreateWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AliasApi()

var body = ; // {SignedCreateAliasRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.signedCreate(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class signedCreateExample
    {
        public void main()
        {
            
            var apiInstance = new AliasApi();
            var body = new SignedCreateAliasRequest(); // SignedCreateAliasRequest | Json with data

            try
            {
                // Broadcasts a signed alias transaction
                apiInstance.signedCreate(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AliasApi.signedCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AliasApi();
$body = ; // SignedCreateAliasRequest | Json with data

try {
    $api_instance->signedCreate($body);
} catch (Exception $e) {
    echo 'Exception when calling AliasApi->signedCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AliasApi;

my $api_instance = WWW::SwaggerClient::AliasApi->new();
my $body = WWW::SwaggerClient::Object::SignedCreateAliasRequest->new(); # SignedCreateAliasRequest | Json with data

eval { 
    $api_instance->signedCreate(body => $body);
};
if ($@) {
    warn "Exception when calling AliasApi->signedCreate: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AliasApi()
body =  # SignedCreateAliasRequest | Json with data

try: 
    # Broadcasts a signed alias transaction
    api_instance.signed_create(body)
except ApiException as e:
    print("Exception when calling AliasApi->signedCreate: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with response or error


Assets

balanceDistribution

Asset balance distribution

Asset balance distribution by account


/assets/{assetId}/distribution

Usage and SDK Samples

curl -X GET "http://localhost/assets/{assetId}/distribution"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        String assetId = assetId_example; // String | Asset ID
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceDistribution(assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#balanceDistribution");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        String assetId = assetId_example; // String | Asset ID
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balanceDistribution(assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#balanceDistribution");
            e.printStackTrace();
        }
    }
}
String *assetId = assetId_example; // Asset ID

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

// Asset balance distribution
[apiInstance balanceDistributionWith:assetId
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var assetId = assetId_example; // {String} Asset ID


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.balanceDistribution(assetId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class balanceDistributionExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var assetId = assetId_example;  // String | Asset ID

            try
            {
                // Asset balance distribution
                Function1RequestContextFutureRouteResult result = apiInstance.balanceDistribution(assetId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.balanceDistribution: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$assetId = assetId_example; // String | Asset ID

try {
    $result = $api_instance->balanceDistribution($assetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->balanceDistribution: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $assetId = assetId_example; # String | Asset ID

eval { 
    my $result = $api_instance->balanceDistribution(assetId => $assetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->balanceDistribution: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
assetId = assetId_example # String | Asset ID

try: 
    # Asset balance distribution
    api_response = api_instance.balance_distribution(assetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->balanceDistribution: %s\n" % e)

Parameters

Path parameters
Name Description
assetId*
String
Asset ID
Required

Responses

Status: 200 - successful operation


balances

Account's balance

Account's balances for all assets


/assets/balance/{address}

Usage and SDK Samples

curl -X GET "http://localhost/assets/balance/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balances(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#balances");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.balances(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#balances");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Account's balance
[apiInstance balancesWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.balances(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class balancesExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var address = address_example;  // String | Address

            try
            {
                // Account's balance
                Function1RequestContextFutureRouteResult result = apiInstance.balances(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.balances: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->balances($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->balances: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->balances(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->balances: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
address = address_example # String | Address

try: 
    # Account's balance
    api_response = api_instance.balances(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->balances: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


batchTransfer

Batch transfer operation

Transfer assets to new addresses


/assets/broadcast/batch-transfer

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/batch-transfer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset transfer transaction body = ; // Signed Asset transfer transaction | Array json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.batchTransfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#batchTransfer");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset transfer transaction body = ; // Signed Asset transfer transaction | Array json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.batchTransfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#batchTransfer");
            e.printStackTrace();
        }
    }
}
Signed Asset transfer transaction *body = ; // Array json with data

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

// Batch transfer operation
[apiInstance batchTransferWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {Signed Asset transfer transaction} Array json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.batchTransfer(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class batchTransferExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new Signed Asset transfer transaction(); // Signed Asset transfer transaction | Array json with data

            try
            {
                // Batch transfer operation
                Function1RequestContextFutureRouteResult result = apiInstance.batchTransfer(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.batchTransfer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // Signed Asset transfer transaction | Array json with data

try {
    $result = $api_instance->batchTransfer($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->batchTransfer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::Signed Asset transfer transaction->new(); # Signed Asset transfer transaction | Array json with data

eval { 
    my $result = $api_instance->batchTransfer(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->batchTransfer: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # Signed Asset transfer transaction | Array json with data

try: 
    # Batch transfer operation
    api_response = api_instance.batch_transfer(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->batchTransfer: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


broadcastAssetBurnTransaction

Broadcast signed Asset burn transaction

Publish signed Asset burn transaction to the Blockchain


/assets/broadcast/burn

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/burn"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        SignedBurnRequest body = ; // SignedBurnRequest | Json with signed Burn transaction
        try {
            apiInstance.broadcastAssetBurnTransaction(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastAssetBurnTransaction");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        SignedBurnRequest body = ; // SignedBurnRequest | Json with signed Burn transaction
        try {
            apiInstance.broadcastAssetBurnTransaction(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastAssetBurnTransaction");
            e.printStackTrace();
        }
    }
}
SignedBurnRequest *body = ; // Json with signed Burn transaction

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

// Broadcast signed Asset burn transaction
[apiInstance broadcastAssetBurnTransactionWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {SignedBurnRequest} Json with signed Burn transaction


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.broadcastAssetBurnTransaction(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class broadcastAssetBurnTransactionExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new SignedBurnRequest(); // SignedBurnRequest | Json with signed Burn transaction

            try
            {
                // Broadcast signed Asset burn transaction
                apiInstance.broadcastAssetBurnTransaction(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.broadcastAssetBurnTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // SignedBurnRequest | Json with signed Burn transaction

try {
    $api_instance->broadcastAssetBurnTransaction($body);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->broadcastAssetBurnTransaction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::SignedBurnRequest->new(); # SignedBurnRequest | Json with signed Burn transaction

eval { 
    $api_instance->broadcastAssetBurnTransaction(body => $body);
};
if ($@) {
    warn "Exception when calling AssetsApi->broadcastAssetBurnTransaction: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # SignedBurnRequest | Json with signed Burn transaction

try: 
    # Broadcast signed Asset burn transaction
    api_instance.broadcast_asset_burn_transaction(body)
except ApiException as e:
    print("Exception when calling AssetsApi->broadcastAssetBurnTransaction: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with signed Asset burn transaction

Status: 400 - Json with error description


broadcastSignedAssetIssue

Broadcast signed Asset issue

Publish signed Asset issue transaction to the Blockchain


/assets/broadcast/issue

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/issue"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset issue transaction body = ; // Signed Asset issue transaction | Json with signed Issue transaction
        try {
            apiInstance.broadcastSignedAssetIssue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetIssue");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset issue transaction body = ; // Signed Asset issue transaction | Json with signed Issue transaction
        try {
            apiInstance.broadcastSignedAssetIssue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetIssue");
            e.printStackTrace();
        }
    }
}
Signed Asset issue transaction *body = ; // Json with signed Issue transaction

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

// Broadcast signed Asset issue
[apiInstance broadcastSignedAssetIssueWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {Signed Asset issue transaction} Json with signed Issue transaction


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.broadcastSignedAssetIssue(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class broadcastSignedAssetIssueExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new Signed Asset issue transaction(); // Signed Asset issue transaction | Json with signed Issue transaction

            try
            {
                // Broadcast signed Asset issue
                apiInstance.broadcastSignedAssetIssue(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.broadcastSignedAssetIssue: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // Signed Asset issue transaction | Json with signed Issue transaction

try {
    $api_instance->broadcastSignedAssetIssue($body);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->broadcastSignedAssetIssue: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::Signed Asset issue transaction->new(); # Signed Asset issue transaction | Json with signed Issue transaction

eval { 
    $api_instance->broadcastSignedAssetIssue(body => $body);
};
if ($@) {
    warn "Exception when calling AssetsApi->broadcastSignedAssetIssue: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # Signed Asset issue transaction | Json with signed Issue transaction

try: 
    # Broadcast signed Asset issue
    api_instance.broadcast_signed_asset_issue(body)
except ApiException as e:
    print("Exception when calling AssetsApi->broadcastSignedAssetIssue: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with signed Asset issue transaction contained Asset ID

Status: 400 - Json with error description


broadcastSignedAssetReissue

Broadcast signed Asset reissue

Publish signed Asset reissue transaction to the Blockchain


/assets/broadcast/reissue

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/reissue"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        SignedReissueRequest body = ; // SignedReissueRequest | Json with signed Reissue transaction
        try {
            apiInstance.broadcastSignedAssetReissue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetReissue");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        SignedReissueRequest body = ; // SignedReissueRequest | Json with signed Reissue transaction
        try {
            apiInstance.broadcastSignedAssetReissue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetReissue");
            e.printStackTrace();
        }
    }
}
SignedReissueRequest *body = ; // Json with signed Reissue transaction

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

// Broadcast signed Asset reissue
[apiInstance broadcastSignedAssetReissueWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {SignedReissueRequest} Json with signed Reissue transaction


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.broadcastSignedAssetReissue(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class broadcastSignedAssetReissueExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new SignedReissueRequest(); // SignedReissueRequest | Json with signed Reissue transaction

            try
            {
                // Broadcast signed Asset reissue
                apiInstance.broadcastSignedAssetReissue(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.broadcastSignedAssetReissue: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // SignedReissueRequest | Json with signed Reissue transaction

try {
    $api_instance->broadcastSignedAssetReissue($body);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->broadcastSignedAssetReissue: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::SignedReissueRequest->new(); # SignedReissueRequest | Json with signed Reissue transaction

eval { 
    $api_instance->broadcastSignedAssetReissue(body => $body);
};
if ($@) {
    warn "Exception when calling AssetsApi->broadcastSignedAssetReissue: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # SignedReissueRequest | Json with signed Reissue transaction

try: 
    # Broadcast signed Asset reissue
    api_instance.broadcast_signed_asset_reissue(body)
except ApiException as e:
    print("Exception when calling AssetsApi->broadcastSignedAssetReissue: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with signed Asset reissue transaction

Status: 400 - Json with error description


broadcastSignedAssetTransfer

Broadcast signed Asset transfer

Publish signed Asset transfer transaction to the Blockchain


/assets/broadcast/transfer

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/transfer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset transfer transaction body = ; // Signed Asset transfer transaction | Json with signed Transfer transaction
        try {
            apiInstance.broadcastSignedAssetTransfer(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetTransfer");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        Signed Asset transfer transaction body = ; // Signed Asset transfer transaction | Json with signed Transfer transaction
        try {
            apiInstance.broadcastSignedAssetTransfer(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#broadcastSignedAssetTransfer");
            e.printStackTrace();
        }
    }
}
Signed Asset transfer transaction *body = ; // Json with signed Transfer transaction

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

// Broadcast signed Asset transfer
[apiInstance broadcastSignedAssetTransferWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {Signed Asset transfer transaction} Json with signed Transfer transaction


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.broadcastSignedAssetTransfer(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class broadcastSignedAssetTransferExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new Signed Asset transfer transaction(); // Signed Asset transfer transaction | Json with signed Transfer transaction

            try
            {
                // Broadcast signed Asset transfer
                apiInstance.broadcastSignedAssetTransfer(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.broadcastSignedAssetTransfer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // Signed Asset transfer transaction | Json with signed Transfer transaction

try {
    $api_instance->broadcastSignedAssetTransfer($body);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->broadcastSignedAssetTransfer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::Signed Asset transfer transaction->new(); # Signed Asset transfer transaction | Json with signed Transfer transaction

eval { 
    $api_instance->broadcastSignedAssetTransfer(body => $body);
};
if ($@) {
    warn "Exception when calling AssetsApi->broadcastSignedAssetTransfer: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # Signed Asset transfer transaction | Json with signed Transfer transaction

try: 
    # Broadcast signed Asset transfer
    api_instance.broadcast_signed_asset_transfer(body)
except ApiException as e:
    print("Exception when calling AssetsApi->broadcastSignedAssetTransfer: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with signed Asset transfer transaction

Status: 400 - Json with error description


burnRoute

Burn Asset

Burn some of your assets


/assets/burn

Usage and SDK Samples

curl -X POST "http://localhost/assets/burn"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        BurnRequest body = ; // BurnRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.burnRoute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#burnRoute");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        BurnRequest body = ; // BurnRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.burnRoute(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#burnRoute");
            e.printStackTrace();
        }
    }
}
BurnRequest *body = ; // Json with data

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

// Burn Asset
[apiInstance burnRouteWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {BurnRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.burnRoute(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class burnRouteExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new BurnRequest(); // BurnRequest | Json with data

            try
            {
                // Burn Asset
                Function1RequestContextFutureRouteResult result = apiInstance.burnRoute(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.burnRoute: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // BurnRequest | Json with data

try {
    $result = $api_instance->burnRoute($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->burnRoute: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::BurnRequest->new(); # BurnRequest | Json with data

eval { 
    my $result = $api_instance->burnRoute(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->burnRoute: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # BurnRequest | Json with data

try: 
    # Burn Asset
    api_response = api_instance.burn_route(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->burnRoute: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


exchange

Broadcast signed Exchange transaction

Publish signed Exchange transaction to the Blockchain


/assets/broadcast/exchange

Usage and SDK Samples

curl -X POST "http://localhost/assets/broadcast/exchange"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        SignedExchangeRequest body = ; // SignedExchangeRequest | Json with signed Transfer transaction
        try {
            apiInstance.exchange(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#exchange");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        SignedExchangeRequest body = ; // SignedExchangeRequest | Json with signed Transfer transaction
        try {
            apiInstance.exchange(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#exchange");
            e.printStackTrace();
        }
    }
}
SignedExchangeRequest *body = ; // Json with signed Transfer transaction

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

// Broadcast signed Exchange transaction
[apiInstance exchangeWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {SignedExchangeRequest} Json with signed Transfer transaction


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.exchange(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class exchangeExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new SignedExchangeRequest(); // SignedExchangeRequest | Json with signed Transfer transaction

            try
            {
                // Broadcast signed Exchange transaction
                apiInstance.exchange(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.exchange: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // SignedExchangeRequest | Json with signed Transfer transaction

try {
    $api_instance->exchange($body);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->exchange: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::SignedExchangeRequest->new(); # SignedExchangeRequest | Json with signed Transfer transaction

eval { 
    $api_instance->exchange(body => $body);
};
if ($@) {
    warn "Exception when calling AssetsApi->exchange: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # SignedExchangeRequest | Json with signed Transfer transaction

try: 
    # Broadcast signed Exchange transaction
    api_instance.exchange(body)
except ApiException as e:
    print("Exception when calling AssetsApi->exchange: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Json with signed Exchange transfer transaction

Status: 400 - Json with error description


getBalanceForAddress

Asset's balance

Account's balance by given asset


/assets/balance/{address}/{assetId}

Usage and SDK Samples

curl -X GET "http://localhost/assets/balance/{address}/{assetId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        String address = address_example; // String | Address
        String assetId = assetId_example; // String | Asset ID
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.getBalanceForAddress(address, assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#getBalanceForAddress");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        String address = address_example; // String | Address
        String assetId = assetId_example; // String | Asset ID
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.getBalanceForAddress(address, assetId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#getBalanceForAddress");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address
String *assetId = assetId_example; // Asset ID

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

// Asset's balance
[apiInstance getBalanceForAddressWith:address
    assetId:assetId
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var address = address_example; // {String} Address

var assetId = assetId_example; // {String} Asset ID


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBalanceForAddress(address, assetId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBalanceForAddressExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var address = address_example;  // String | Address
            var assetId = assetId_example;  // String | Asset ID

            try
            {
                // Asset's balance
                Function1RequestContextFutureRouteResult result = apiInstance.getBalanceForAddress(address, assetId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.getBalanceForAddress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$address = address_example; // String | Address
$assetId = assetId_example; // String | Asset ID

try {
    $result = $api_instance->getBalanceForAddress($address, $assetId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->getBalanceForAddress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $address = address_example; # String | Address
my $assetId = assetId_example; # String | Asset ID

eval { 
    my $result = $api_instance->getBalanceForAddress(address => $address, assetId => $assetId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->getBalanceForAddress: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
address = address_example # String | Address
assetId = assetId_example # String | Asset ID

try: 
    # Asset's balance
    api_response = api_instance.get_balance_for_address(address, assetId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->getBalanceForAddress: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required
assetId*
String
Asset ID
Required

Responses

Status: 200 - successful operation


issue

Issue Asset

Issue new Asset


/assets/issue

Usage and SDK Samples

curl -X POST "http://localhost/assets/issue"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        IssueRequest body = ; // IssueRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.issue(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#issue");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        IssueRequest body = ; // IssueRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.issue(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#issue");
            e.printStackTrace();
        }
    }
}
IssueRequest *body = ; // Json with data

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

// Issue Asset
[apiInstance issueWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {IssueRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.issue(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class issueExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new IssueRequest(); // IssueRequest | Json with data

            try
            {
                // Issue Asset
                Function1RequestContextFutureRouteResult result = apiInstance.issue(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.issue: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // IssueRequest | Json with data

try {
    $result = $api_instance->issue($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->issue: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::IssueRequest->new(); # IssueRequest | Json with data

eval { 
    my $result = $api_instance->issue(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->issue: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # IssueRequest | Json with data

try: 
    # Issue Asset
    api_response = api_instance.issue(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->issue: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


massTransfer

Mass Transfer

Mass transfer of assets


/assets/masstransfer

Usage and SDK Samples

curl -X POST "http://localhost/assets/masstransfer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        MassTransferRequest body = ; // MassTransferRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.massTransfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#massTransfer");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        MassTransferRequest body = ; // MassTransferRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.massTransfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#massTransfer");
            e.printStackTrace();
        }
    }
}
MassTransferRequest *body = ; // Json with data

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

// Mass Transfer
[apiInstance massTransferWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {MassTransferRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.massTransfer(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class massTransferExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new MassTransferRequest(); // MassTransferRequest | Json with data

            try
            {
                // Mass Transfer
                Function1RequestContextFutureRouteResult result = apiInstance.massTransfer(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.massTransfer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // MassTransferRequest | Json with data

try {
    $result = $api_instance->massTransfer($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->massTransfer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::MassTransferRequest->new(); # MassTransferRequest | Json with data

eval { 
    my $result = $api_instance->massTransfer(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->massTransfer: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # MassTransferRequest | Json with data

try: 
    # Mass Transfer
    api_response = api_instance.mass_transfer(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->massTransfer: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


reissue

Issue Asset

Reissue Asset


/assets/reissue

Usage and SDK Samples

curl -X POST "http://localhost/assets/reissue"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        ReissueRequest body = ; // ReissueRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.reissue(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#reissue");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        ReissueRequest body = ; // ReissueRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.reissue(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#reissue");
            e.printStackTrace();
        }
    }
}
ReissueRequest *body = ; // Json with data

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

// Issue Asset
[apiInstance reissueWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {ReissueRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.reissue(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class reissueExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new ReissueRequest(); // ReissueRequest | Json with data

            try
            {
                // Issue Asset
                Function1RequestContextFutureRouteResult result = apiInstance.reissue(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.reissue: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // ReissueRequest | Json with data

try {
    $result = $api_instance->reissue($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->reissue: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::ReissueRequest->new(); # ReissueRequest | Json with data

eval { 
    my $result = $api_instance->reissue(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->reissue: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # ReissueRequest | Json with data

try: 
    # Issue Asset
    api_response = api_instance.reissue(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->reissue: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


signOrder

Sign Order

Create order signed by address from wallet


/assets/order

Usage and SDK Samples

curl -X POST "http://localhost/assets/order"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        Order body = ; // Order | Order Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.signOrder(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#signOrder");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        Order body = ; // Order | Order Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.signOrder(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#signOrder");
            e.printStackTrace();
        }
    }
}
Order *body = ; // Order Json with data

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

// Sign Order
[apiInstance signOrderWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {Order} Order Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.signOrder(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class signOrderExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new Order(); // Order | Order Json with data

            try
            {
                // Sign Order
                Function1RequestContextFutureRouteResult result = apiInstance.signOrder(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.signOrder: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // Order | Order Json with data

try {
    $result = $api_instance->signOrder($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->signOrder: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::Order->new(); # Order | Order Json with data

eval { 
    my $result = $api_instance->signOrder(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->signOrder: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # Order | Order Json with data

try: 
    # Sign Order
    api_response = api_instance.sign_order(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->signOrder: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


transfer

Transfer asset

Transfer asset to new address


/assets/transfer

Usage and SDK Samples

curl -X POST "http://localhost/assets/transfer"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AssetsApi;

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

public class AssetsApiExample {

    public static void main(String[] args) {
        
        AssetsApi apiInstance = new AssetsApi();
        TransferRequest body = ; // TransferRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.transfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#transfer");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AssetsApi;

public class AssetsApiExample {

    public static void main(String[] args) {
        AssetsApi apiInstance = new AssetsApi();
        TransferRequest body = ; // TransferRequest | Json with data
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.transfer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AssetsApi#transfer");
            e.printStackTrace();
        }
    }
}
TransferRequest *body = ; // Json with data

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

// Transfer asset
[apiInstance transferWith:body
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.AssetsApi()

var body = ; // {TransferRequest} Json with data


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.transfer(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class transferExample
    {
        public void main()
        {
            
            var apiInstance = new AssetsApi();
            var body = new TransferRequest(); // TransferRequest | Json with data

            try
            {
                // Transfer asset
                Function1RequestContextFutureRouteResult result = apiInstance.transfer(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AssetsApi.transfer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AssetsApi();
$body = ; // TransferRequest | Json with data

try {
    $result = $api_instance->transfer($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AssetsApi->transfer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AssetsApi;

my $api_instance = WWW::SwaggerClient::AssetsApi->new();
my $body = WWW::SwaggerClient::Object::TransferRequest->new(); # TransferRequest | Json with data

eval { 
    my $result = $api_instance->transfer(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AssetsApi->transfer: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AssetsApi()
body =  # TransferRequest | Json with data

try: 
    # Transfer asset
    api_response = api_instance.transfer(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AssetsApi->transfer: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


Blocks

address

Address

Get list of blocks generated by specified address


/blocks/address/{address}/{from}/{to}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/address/{address}/{from}/{to}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        String address = address_example; // String | Wallet address 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.address(from, to, address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#address");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        String address = address_example; // String | Wallet address 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.address(from, to, address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#address");
            e.printStackTrace();
        }
    }
}
Integer *from = 56; // Start block height
Integer *to = 56; // End block height
String *address = address_example; // Wallet address 

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

// Address
[apiInstance addressWith:from
    to:to
    address:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var from = 56; // {Integer} Start block height

var to = 56; // {Integer} End block height

var address = address_example; // {String} Wallet address 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.address(from, to, address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class addressExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var from = 56;  // Integer | Start block height
            var to = 56;  // Integer | End block height
            var address = address_example;  // String | Wallet address 

            try
            {
                // Address
                Function1RequestContextFutureRouteResult result = apiInstance.address(from, to, address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.address: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$from = 56; // Integer | Start block height
$to = 56; // Integer | End block height
$address = address_example; // String | Wallet address 

try {
    $result = $api_instance->address($from, $to, $address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->address: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $from = 56; # Integer | Start block height
my $to = 56; # Integer | End block height
my $address = address_example; # String | Wallet address 

eval { 
    my $result = $api_instance->address(from => $from, to => $to, address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->address: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
from = 56 # Integer | Start block height
to = 56 # Integer | End block height
address = address_example # String | Wallet address 

try: 
    # Address
    api_response = api_instance.address(from, to, address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->address: %s\n" % e)

Parameters

Path parameters
Name Description
from*
Integer
Start block height
Required
to*
Integer
End block height
Required
address*
String
Wallet address
Required

Responses

Status: 200 - successful operation


at

At

Get block at specified height


/blocks/at/{height}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/at/{height}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Integer height = 56; // Integer | Block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.at(height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#at");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Integer height = 56; // Integer | Block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.at(height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#at");
            e.printStackTrace();
        }
    }
}
Integer *height = 56; // Block height

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

// At
[apiInstance atWith:height
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var height = 56; // {Integer} Block height


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.at(height, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class atExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var height = 56;  // Integer | Block height

            try
            {
                // At
                Function1RequestContextFutureRouteResult result = apiInstance.at(height);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.at: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$height = 56; // Integer | Block height

try {
    $result = $api_instance->at($height);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->at: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $height = 56; # Integer | Block height

eval { 
    my $result = $api_instance->at(height => $height);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->at: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
height = 56 # Integer | Block height

try: 
    # At
    api_response = api_instance.at(height)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->at: %s\n" % e)

Parameters

Path parameters
Name Description
height*
Integer
Block height
Required

Responses

Status: 200 - successful operation


atHeaderOnly

At(Block header only)

Get block at specified height without transactions payload


/blocks/headers/at/{height}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/headers/at/{height}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Integer height = 56; // Integer | Block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.atHeaderOnly(height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#atHeaderOnly");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Integer height = 56; // Integer | Block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.atHeaderOnly(height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#atHeaderOnly");
            e.printStackTrace();
        }
    }
}
Integer *height = 56; // Block height

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

// At(Block header only)
[apiInstance atHeaderOnlyWith:height
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var height = 56; // {Integer} Block height


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.atHeaderOnly(height, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class atHeaderOnlyExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var height = 56;  // Integer | Block height

            try
            {
                // At(Block header only)
                Function1RequestContextFutureRouteResult result = apiInstance.atHeaderOnly(height);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.atHeaderOnly: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$height = 56; // Integer | Block height

try {
    $result = $api_instance->atHeaderOnly($height);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->atHeaderOnly: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $height = 56; # Integer | Block height

eval { 
    my $result = $api_instance->atHeaderOnly(height => $height);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->atHeaderOnly: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
height = 56 # Integer | Block height

try: 
    # At(Block header only)
    api_response = api_instance.at_header_only(height)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->atHeaderOnly: %s\n" % e)

Parameters

Path parameters
Name Description
height*
Integer
Block height
Required

Responses

Status: 200 - successful operation


checkpoint

Checkpoint

Broadcast checkpoint of blocks


/blocks/checkpoint

Usage and SDK Samples

curl -X POST "http://localhost/blocks/checkpoint"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Checkpoint message = ; // Checkpoint | Checkpoint message
        try {
            apiInstance.checkpoint(message);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#checkpoint");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Checkpoint message = ; // Checkpoint | Checkpoint message
        try {
            apiInstance.checkpoint(message);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#checkpoint");
            e.printStackTrace();
        }
    }
}
Checkpoint *message = ; // Checkpoint message

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

// Checkpoint
[apiInstance checkpointWith:message
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var message = ; // {Checkpoint} Checkpoint message


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.checkpoint(message, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class checkpointExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var message = new Checkpoint(); // Checkpoint | Checkpoint message

            try
            {
                // Checkpoint
                apiInstance.checkpoint(message);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.checkpoint: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$message = ; // Checkpoint | Checkpoint message

try {
    $api_instance->checkpoint($message);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->checkpoint: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $message = WWW::SwaggerClient::Object::Checkpoint->new(); # Checkpoint | Checkpoint message

eval { 
    $api_instance->checkpoint(message => $message);
};
if ($@) {
    warn "Exception when calling BlocksApi->checkpoint: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
message =  # Checkpoint | Checkpoint message

try: 
    # Checkpoint
    api_instance.checkpoint(message)
except ApiException as e:
    print("Exception when calling BlocksApi->checkpoint: %s\n" % e)

Parameters

Body parameters
Name Description
message *

Responses

Status: 200 - Json with response or error


child

Child

Get children of specified block


/blocks/child/{signature}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/child/{signature}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.child(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#child");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.child(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#child");
            e.printStackTrace();
        }
    }
}
String *signature = signature_example; // Base58-encoded signature

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

// Child
[apiInstance childWith:signature
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var signature = signature_example; // {String} Base58-encoded signature


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.child(signature, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class childExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var signature = signature_example;  // String | Base58-encoded signature

            try
            {
                // Child
                Function1RequestContextFutureRouteResult result = apiInstance.child(signature);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.child: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$signature = signature_example; // String | Base58-encoded signature

try {
    $result = $api_instance->child($signature);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->child: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $signature = signature_example; # String | Base58-encoded signature

eval { 
    my $result = $api_instance->child(signature => $signature);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->child: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
signature = signature_example # String | Base58-encoded signature

try: 
    # Child
    api_response = api_instance.child(signature)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->child: %s\n" % e)

Parameters

Path parameters
Name Description
signature*
String
Base58-encoded signature
Required

Responses

Status: 200 - successful operation


delay

Average delay

Average delay in milliseconds between last `blockNum` blocks starting from block with `signature`


/blocks/delay/{signature}/{blockNum}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/delay/{signature}/{blockNum}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        String blockNum = blockNum_example; // String | Number of blocks to count delay
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.delay(signature, blockNum);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#delay");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        String blockNum = blockNum_example; // String | Number of blocks to count delay
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.delay(signature, blockNum);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#delay");
            e.printStackTrace();
        }
    }
}
String *signature = signature_example; // Base58-encoded signature
String *blockNum = blockNum_example; // Number of blocks to count delay

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

// Average delay
[apiInstance delayWith:signature
    blockNum:blockNum
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var signature = signature_example; // {String} Base58-encoded signature

var blockNum = blockNum_example; // {String} Number of blocks to count delay


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.delay(signature, blockNum, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class delayExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var signature = signature_example;  // String | Base58-encoded signature
            var blockNum = blockNum_example;  // String | Number of blocks to count delay

            try
            {
                // Average delay
                Function1RequestContextFutureRouteResult result = apiInstance.delay(signature, blockNum);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.delay: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$signature = signature_example; // String | Base58-encoded signature
$blockNum = blockNum_example; // String | Number of blocks to count delay

try {
    $result = $api_instance->delay($signature, $blockNum);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->delay: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $signature = signature_example; # String | Base58-encoded signature
my $blockNum = blockNum_example; # String | Number of blocks to count delay

eval { 
    my $result = $api_instance->delay(signature => $signature, blockNum => $blockNum);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->delay: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
signature = signature_example # String | Base58-encoded signature
blockNum = blockNum_example # String | Number of blocks to count delay

try: 
    # Average delay
    api_response = api_instance.delay(signature, blockNum)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->delay: %s\n" % e)

Parameters

Path parameters
Name Description
signature*
String
Base58-encoded signature
Required
blockNum*
String
Number of blocks to count delay
Required

Responses

Status: 200 - successful operation


first

First

Get genesis block data


/blocks/first

Usage and SDK Samples

curl -X GET "http://localhost/blocks/first"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.first();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#first");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

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

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

// First
[apiInstance firstWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.first(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class firstExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();

            try
            {
                // First
                Function1RequestContextFutureRouteResult result = apiInstance.first();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.first: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();

try {
    $result = $api_instance->first();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->first: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();

eval { 
    my $result = $api_instance->first();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->first: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()

try: 
    # First
    api_response = api_instance.first()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->first: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getBlockSeqFromTo

Seq

Get block at specified heights


/blocks/seq/{from}/{to}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/seq/{from}/{to}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.getBlockSeqFromTo(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#getBlockSeqFromTo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.getBlockSeqFromTo(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#getBlockSeqFromTo");
            e.printStackTrace();
        }
    }
}
Integer *from = 56; // Start block height
Integer *to = 56; // End block height

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

// Seq
[apiInstance getBlockSeqFromToWith:from
    to:to
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var from = 56; // {Integer} Start block height

var to = 56; // {Integer} End block height


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBlockSeqFromTo(from, to, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBlockSeqFromToExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var from = 56;  // Integer | Start block height
            var to = 56;  // Integer | End block height

            try
            {
                // Seq
                Function1RequestContextFutureRouteResult result = apiInstance.getBlockSeqFromTo(from, to);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.getBlockSeqFromTo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$from = 56; // Integer | Start block height
$to = 56; // Integer | End block height

try {
    $result = $api_instance->getBlockSeqFromTo($from, $to);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->getBlockSeqFromTo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $from = 56; # Integer | Start block height
my $to = 56; # Integer | End block height

eval { 
    my $result = $api_instance->getBlockSeqFromTo(from => $from, to => $to);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->getBlockSeqFromTo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
from = 56 # Integer | Start block height
to = 56 # Integer | End block height

try: 
    # Seq
    api_response = api_instance.get_block_seq_from_to(from, to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->getBlockSeqFromTo: %s\n" % e)

Parameters

Path parameters
Name Description
from*
Integer
Start block height
Required
to*
Integer
End block height
Required

Responses

Status: 200 - successful operation


height

Height

Get blockchain height


/blocks/height

Usage and SDK Samples

curl -X GET "http://localhost/blocks/height"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.height();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#height");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

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

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

// Height
[apiInstance heightWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.height(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class heightExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();

            try
            {
                // Height
                Function1RequestContextFutureRouteResult result = apiInstance.height();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.height: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();

try {
    $result = $api_instance->height();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->height: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();

eval { 
    my $result = $api_instance->height();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->height: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()

try: 
    # Height
    api_response = api_instance.height()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->height: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


heightEncoded

Height

Get height of a block by its Base58-encoded signature


/blocks/height/{signature}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/height/{signature}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.heightEncoded(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#heightEncoded");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.heightEncoded(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#heightEncoded");
            e.printStackTrace();
        }
    }
}
String *signature = signature_example; // Base58-encoded signature

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

// Height
[apiInstance heightEncodedWith:signature
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var signature = signature_example; // {String} Base58-encoded signature


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.heightEncoded(signature, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class heightEncodedExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var signature = signature_example;  // String | Base58-encoded signature

            try
            {
                // Height
                Function1RequestContextFutureRouteResult result = apiInstance.heightEncoded(signature);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.heightEncoded: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$signature = signature_example; // String | Base58-encoded signature

try {
    $result = $api_instance->heightEncoded($signature);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->heightEncoded: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $signature = signature_example; # String | Base58-encoded signature

eval { 
    my $result = $api_instance->heightEncoded(signature => $signature);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->heightEncoded: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
signature = signature_example # String | Base58-encoded signature

try: 
    # Height
    api_response = api_instance.height_encoded(signature)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->heightEncoded: %s\n" % e)

Parameters

Path parameters
Name Description
signature*
String
Base58-encoded signature
Required

Responses

Status: 200 - successful operation


last

Last

Get last block data


/blocks/last

Usage and SDK Samples

curl -X GET "http://localhost/blocks/last"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.last();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#last");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

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

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

// Last
[apiInstance lastWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.last(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lastExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();

            try
            {
                // Last
                Function1RequestContextFutureRouteResult result = apiInstance.last();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.last: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();

try {
    $result = $api_instance->last();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->last: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();

eval { 
    my $result = $api_instance->last();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->last: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()

try: 
    # Last
    api_response = api_instance.last()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->last: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


lastHeaderOnly

Last

Get last block data without transactions payload


/blocks/headers/last

Usage and SDK Samples

curl -X GET "http://localhost/blocks/headers/last"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.lastHeaderOnly();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#lastHeaderOnly");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

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

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

// Last
[apiInstance lastHeaderOnlyWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.lastHeaderOnly(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lastHeaderOnlyExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();

            try
            {
                // Last
                Function1RequestContextFutureRouteResult result = apiInstance.lastHeaderOnly();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.lastHeaderOnly: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();

try {
    $result = $api_instance->lastHeaderOnly();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->lastHeaderOnly: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();

eval { 
    my $result = $api_instance->lastHeaderOnly();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->lastHeaderOnly: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()

try: 
    # Last
    api_response = api_instance.last_header_only()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->lastHeaderOnly: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


seqHeaderOnly

Seq (Block header only)

Get block without transactions payload at specified heights


/blocks/headers/seq/{from}/{to}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/headers/seq/{from}/{to}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seqHeaderOnly(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#seqHeaderOnly");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        Integer from = 56; // Integer | Start block height
        Integer to = 56; // Integer | End block height
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.seqHeaderOnly(from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#seqHeaderOnly");
            e.printStackTrace();
        }
    }
}
Integer *from = 56; // Start block height
Integer *to = 56; // End block height

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

// Seq (Block header only)
[apiInstance seqHeaderOnlyWith:from
    to:to
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var from = 56; // {Integer} Start block height

var to = 56; // {Integer} End block height


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.seqHeaderOnly(from, to, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class seqHeaderOnlyExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var from = 56;  // Integer | Start block height
            var to = 56;  // Integer | End block height

            try
            {
                // Seq (Block header only)
                Function1RequestContextFutureRouteResult result = apiInstance.seqHeaderOnly(from, to);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.seqHeaderOnly: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$from = 56; // Integer | Start block height
$to = 56; // Integer | End block height

try {
    $result = $api_instance->seqHeaderOnly($from, $to);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->seqHeaderOnly: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $from = 56; # Integer | Start block height
my $to = 56; # Integer | End block height

eval { 
    my $result = $api_instance->seqHeaderOnly(from => $from, to => $to);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->seqHeaderOnly: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
from = 56 # Integer | Start block height
to = 56 # Integer | End block height

try: 
    # Seq (Block header only)
    api_response = api_instance.seq_header_only(from, to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->seqHeaderOnly: %s\n" % e)

Parameters

Path parameters
Name Description
from*
Integer
Start block height
Required
to*
Integer
End block height
Required

Responses

Status: 200 - successful operation


signature

Signature

Get block by a specified Base58-encoded signature


/blocks/signature/{signature}

Usage and SDK Samples

curl -X GET "http://localhost/blocks/signature/{signature}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlocksApi;

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

public class BlocksApiExample {

    public static void main(String[] args) {
        
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.signature(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#signature");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlocksApi;

public class BlocksApiExample {

    public static void main(String[] args) {
        BlocksApi apiInstance = new BlocksApi();
        String signature = signature_example; // String | Base58-encoded signature
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.signature(signature);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlocksApi#signature");
            e.printStackTrace();
        }
    }
}
String *signature = signature_example; // Base58-encoded signature

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

// Signature
[apiInstance signatureWith:signature
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.BlocksApi()

var signature = signature_example; // {String} Base58-encoded signature


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.signature(signature, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class signatureExample
    {
        public void main()
        {
            
            var apiInstance = new BlocksApi();
            var signature = signature_example;  // String | Base58-encoded signature

            try
            {
                // Signature
                Function1RequestContextFutureRouteResult result = apiInstance.signature(signature);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlocksApi.signature: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\BlocksApi();
$signature = signature_example; // String | Base58-encoded signature

try {
    $result = $api_instance->signature($signature);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlocksApi->signature: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BlocksApi;

my $api_instance = WWW::SwaggerClient::BlocksApi->new();
my $signature = signature_example; # String | Base58-encoded signature

eval { 
    my $result = $api_instance->signature(signature => $signature);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlocksApi->signature: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.BlocksApi()
signature = signature_example # String | Base58-encoded signature

try: 
    # Signature
    api_response = api_instance.signature(signature)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlocksApi->signature: %s\n" % e)

Parameters

Path parameters
Name Description
signature*
String
Base58-encoded signature
Required

Responses

Status: 200 - successful operation


Consensus

algo

Consensus algo

Shows which consensus algo being using


/consensus/algo

Usage and SDK Samples

curl -X GET "http://localhost/consensus/algo"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.algo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#algo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

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

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

// Consensus algo
[apiInstance algoWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.algo(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class algoExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();

            try
            {
                // Consensus algo
                Function1RequestContextFutureRouteResult result = apiInstance.algo();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.algo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();

try {
    $result = $api_instance->algo();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->algo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();

eval { 
    my $result = $api_instance->algo();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->algo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()

try: 
    # Consensus algo
    api_response = api_instance.algo()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->algo: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


baseTargetId

Base target

base target of a block with specified id


/consensus/basetarget/{blockId}

Usage and SDK Samples

curl -X GET "http://localhost/consensus/basetarget/{blockId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        String blockId = blockId_example; // String | Block id 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.baseTargetId(blockId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#baseTargetId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

    public static void main(String[] args) {
        ConsensusApi apiInstance = new ConsensusApi();
        String blockId = blockId_example; // String | Block id 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.baseTargetId(blockId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#baseTargetId");
            e.printStackTrace();
        }
    }
}
String *blockId = blockId_example; // Block id 

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

// Base target
[apiInstance baseTargetIdWith:blockId
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var blockId = blockId_example; // {String} Block id 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.baseTargetId(blockId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class baseTargetIdExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();
            var blockId = blockId_example;  // String | Block id 

            try
            {
                // Base target
                Function1RequestContextFutureRouteResult result = apiInstance.baseTargetId(blockId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.baseTargetId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();
$blockId = blockId_example; // String | Block id 

try {
    $result = $api_instance->baseTargetId($blockId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->baseTargetId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();
my $blockId = blockId_example; # String | Block id 

eval { 
    my $result = $api_instance->baseTargetId(blockId => $blockId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->baseTargetId: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()
blockId = blockId_example # String | Block id 

try: 
    # Base target
    api_response = api_instance.base_target_id(blockId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->baseTargetId: %s\n" % e)

Parameters

Path parameters
Name Description
blockId*
String
Block id
Required

Responses

Status: 200 - successful operation


basetarget

Base target last

Base target of a last block


/consensus/basetarget

Usage and SDK Samples

curl -X GET "http://localhost/consensus/basetarget"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.basetarget();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#basetarget");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

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

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

// Base target last
[apiInstance basetargetWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.basetarget(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class basetargetExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();

            try
            {
                // Base target last
                Function1RequestContextFutureRouteResult result = apiInstance.basetarget();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.basetarget: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();

try {
    $result = $api_instance->basetarget();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->basetarget: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();

eval { 
    my $result = $api_instance->basetarget();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->basetarget: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()

try: 
    # Base target last
    api_response = api_instance.basetarget()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->basetarget: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


generatingBalance

Generating balance

Account's generating balance(the same as balance atm)


/consensus/generatingbalance/{address}

Usage and SDK Samples

curl -X GET "http://localhost/consensus/generatingbalance/{address}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.generatingBalance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#generatingBalance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

    public static void main(String[] args) {
        ConsensusApi apiInstance = new ConsensusApi();
        String address = address_example; // String | Address
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.generatingBalance(address);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#generatingBalance");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // Address

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

// Generating balance
[apiInstance generatingBalanceWith:address
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var address = address_example; // {String} Address


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generatingBalance(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class generatingBalanceExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();
            var address = address_example;  // String | Address

            try
            {
                // Generating balance
                Function1RequestContextFutureRouteResult result = apiInstance.generatingBalance(address);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.generatingBalance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();
$address = address_example; // String | Address

try {
    $result = $api_instance->generatingBalance($address);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->generatingBalance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();
my $address = address_example; # String | Address

eval { 
    my $result = $api_instance->generatingBalance(address => $address);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->generatingBalance: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()
address = address_example # String | Address

try: 
    # Generating balance
    api_response = api_instance.generating_balance(address)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->generatingBalance: %s\n" % e)

Parameters

Path parameters
Name Description
address*
String
Address
Required

Responses

Status: 200 - successful operation


generationSignature

Generation signature last

Generation signature of a last block


/consensus/generationsignature

Usage and SDK Samples

curl -X GET "http://localhost/consensus/generationsignature"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.generationSignature();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#generationSignature");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

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

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

// Generation signature last
[apiInstance generationSignatureWithCompletionHandler: 
              ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generationSignature(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class generationSignatureExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();

            try
            {
                // Generation signature last
                Function1RequestContextFutureRouteResult result = apiInstance.generationSignature();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.generationSignature: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();

try {
    $result = $api_instance->generationSignature();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->generationSignature: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();

eval { 
    my $result = $api_instance->generationSignature();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->generationSignature: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()

try: 
    # Generation signature last
    api_response = api_instance.generation_signature()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->generationSignature: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


generationSignatureId

Generation signature

Generation signature of a block with specified id


/consensus/generationsignature/{blockId}

Usage and SDK Samples

curl -X GET "http://localhost/consensus/generationsignature/{blockId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConsensusApi;

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

public class ConsensusApiExample {

    public static void main(String[] args) {
        
        ConsensusApi apiInstance = new ConsensusApi();
        String blockId = blockId_example; // String | Block id 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.generationSignatureId(blockId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#generationSignatureId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ConsensusApi;

public class ConsensusApiExample {

    public static void main(String[] args) {
        ConsensusApi apiInstance = new ConsensusApi();
        String blockId = blockId_example; // String | Block id 
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.generationSignatureId(blockId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConsensusApi#generationSignatureId");
            e.printStackTrace();
        }
    }
}
String *blockId = blockId_example; // Block id 

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

// Generation signature
[apiInstance generationSignatureIdWith:blockId
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.ConsensusApi()

var blockId = blockId_example; // {String} Block id 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generationSignatureId(blockId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class generationSignatureIdExample
    {
        public void main()
        {
            
            var apiInstance = new ConsensusApi();
            var blockId = blockId_example;  // String | Block id 

            try
            {
                // Generation signature
                Function1RequestContextFutureRouteResult result = apiInstance.generationSignatureId(blockId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ConsensusApi.generationSignatureId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ConsensusApi();
$blockId = blockId_example; // String | Block id 

try {
    $result = $api_instance->generationSignatureId($blockId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConsensusApi->generationSignatureId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConsensusApi;

my $api_instance = WWW::SwaggerClient::ConsensusApi->new();
my $blockId = blockId_example; # String | Block id 

eval { 
    my $result = $api_instance->generationSignatureId(blockId => $blockId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConsensusApi->generationSignatureId: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ConsensusApi()
blockId = blockId_example # String | Block id 

try: 
    # Generation signature
    api_response = api_instance.generation_signature_id(blockId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConsensusApi->generationSignatureId: %s\n" % e)

Parameters

Path parameters
Name Description
blockId*
String
Block id
Required

Responses

Status: 200 - successful operation


Debug

blacklist

Blacklist given peer

Moving peer to blacklist


/debug/blacklist

Usage and SDK Samples

curl -X POST "http://localhost/debug/blacklist"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DebugApi;

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

public class DebugApiExample {

    public static void main(String[] args) {
        
        DebugApi apiInstance = new DebugApi();
        String address = address_example; // String | IP address of node
        try {
            apiInstance.blacklist(address);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#blacklist");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DebugApi;

public class DebugApiExample {

    public static void main(String[] args) {
        DebugApi apiInstance = new DebugApi();
        String address = address_example; // String | IP address of node
        try {
            apiInstance.blacklist(address);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#blacklist");
            e.printStackTrace();
        }
    }
}
String *address = address_example; // IP address of node

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

// Blacklist given peer
[apiInstance blacklistWith:address
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.DebugApi()

var address = address_example; // {String} IP address of node


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.blacklist(address, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class blacklistExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();
            var address = address_example;  // String | IP address of node

            try
            {
                // Blacklist given peer
                apiInstance.blacklist(address);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.blacklist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DebugApi();
$address = address_example; // String | IP address of node

try {
    $api_instance->blacklist($address);
} catch (Exception $e) {
    echo 'Exception when calling DebugApi->blacklist: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DebugApi;

my $api_instance = WWW::SwaggerClient::DebugApi->new();
my $address = WWW::SwaggerClient::Object::String->new(); # String | IP address of node

eval { 
    $api_instance->blacklist(address => $address);
};
if ($@) {
    warn "Exception when calling DebugApi->blacklist: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DebugApi()
address = address_example # String | IP address of node

try: 
    # Blacklist given peer
    api_instance.blacklist(address)
except ApiException as e:
    print("Exception when calling DebugApi->blacklist: %s\n" % e)

Parameters

Body parameters
Name Description
address *

Responses

Status: 200 - 200 if success, 404 if there are no peer with such address


blocks

Blocks

Get sizes and full hashes for last blocks


/debug/blocks/{howMany}

Usage and SDK Samples

curl -X GET "http://localhost/debug/blocks/{howMany}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DebugApi;

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

public class DebugApiExample {

    public static void main(String[] args) {
        
        DebugApi apiInstance = new DebugApi();
        String howMany = howMany_example; // String | How many last blocks to take
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.blocks(howMany);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#blocks");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DebugApi;

public class DebugApiExample {

    public static void main(String[] args) {
        DebugApi apiInstance = new DebugApi();
        String howMany = howMany_example; // String | How many last blocks to take
        try {
            Function1RequestContextFutureRouteResult result = apiInstance.blocks(howMany);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#blocks");
            e.printStackTrace();
        }
    }
}
String *howMany = howMany_example; // How many last blocks to take

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

// Blocks
[apiInstance blocksWith:howMany
              completionHandler: ^(Function1RequestContextFutureRouteResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.DebugApi()

var howMany = howMany_example; // {String} How many last blocks to take


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.blocks(howMany, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class blocksExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();
            var howMany = howMany_example;  // String | How many last blocks to take

            try
            {
                // Blocks
                Function1RequestContextFutureRouteResult result = apiInstance.blocks(howMany);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.blocks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DebugApi();
$howMany = howMany_example; // String | How many last blocks to take

try {
    $result = $api_instance->blocks($howMany);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DebugApi->blocks: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DebugApi;

my $api_instance = WWW::SwaggerClient::DebugApi->new();
my $howMany = howMany_example; # String | How many last blocks to take

eval { 
    my $result = $api_instance->blocks(howMany => $howMany);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DebugApi->blocks: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DebugApi()
howMany = howMany_example # String | How many last blocks to take

try: 
    # Blocks
    api_response = api_instance.blocks(howMany)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DebugApi->blocks: %s\n" % e)

Parameters

Path parameters
Name Description
howMany*
String
How many last blocks to take
Required

Responses

Status: 200 - successful operation


configInfo

Config

Currently running node config


/debug/configInfo

Usage and SDK Samples

curl -X GET "http://localhost/debug/configInfo?full="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DebugApi;

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

public class DebugApiExample {

    public static void main(String[] args) {
        
        DebugApi apiInstance = new DebugApi();
        Boolean full = true; // Boolean | Exposes full typesafe config
        try {
            apiInstance.configInfo(full);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#configInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DebugApi;

public class DebugApiExample {

    public static void main(String[] args) {
        DebugApi apiInstance = new DebugApi();
        Boolean full = true; // Boolean | Exposes full typesafe config
        try {
            apiInstance.configInfo(full);
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#configInfo");
            e.printStackTrace();
        }
    }
}
Boolean *full = true; // Exposes full typesafe config (optional) (default to false)

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

// Config
[apiInstance configInfoWith:full
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.DebugApi()

var opts = { 
  'full': true // {Boolean} Exposes full typesafe config
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.configInfo(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class configInfoExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();
            var full = true;  // Boolean | Exposes full typesafe config (optional)  (default to false)

            try
            {
                // Config
                apiInstance.configInfo(full);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.configInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DebugApi();
$full = true; // Boolean | Exposes full typesafe config

try {
    $api_instance->configInfo($full);
} catch (Exception $e) {
    echo 'Exception when calling DebugApi->configInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DebugApi;

my $api_instance = WWW::SwaggerClient::DebugApi->new();
my $full = true; # Boolean | Exposes full typesafe config

eval { 
    $api_instance->configInfo(full => $full);
};
if ($@) {
    warn "Exception when calling DebugApi->configInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DebugApi()
full = true # Boolean | Exposes full typesafe config (optional) (default to false)

try: 
    # Config
    api_instance.config_info(full=full)
except ApiException as e:
    print("Exception when calling DebugApi->configInfo: %s\n" % e)

Parameters

Query parameters
Name Description
full
Boolean
Exposes full typesafe config

Responses

Status: 200 - Json state


debugInfo

State

All info you need to debug


/debug/info

Usage and SDK Samples

curl -X GET "http://localhost/debug/info"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DebugApi;

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

public class DebugApiExample {

    public static void main(String[] args) {
        
        DebugApi apiInstance = new DebugApi();
        try {
            apiInstance.debugInfo();
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#debugInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DebugApi;

public class DebugApiExample {

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

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

// State
[apiInstance debugInfoWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.DebugApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.debugInfo(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class debugInfoExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();

            try
            {
                // State
                apiInstance.debugInfo();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.debugInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DebugApi();

try {
    $api_instance->debugInfo();
} catch (Exception $e) {
    echo 'Exception when calling DebugApi->debugInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DebugApi;

my $api_instance = WWW::SwaggerClient::DebugApi->new();

eval { 
    $api_instance->debugInfo();
};
if ($@) {
    warn "Exception when calling DebugApi->debugInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DebugApi()

try: 
    # State
    api_instance.debug_info()
except ApiException as e:
    print("Exception when calling DebugApi->debugInfo: %s\n" % e)

Parameters

Responses

Status: 200 - Json state


historyInfo

State

All history info you need to debug


/debug/historyInfo

Usage and SDK Samples

curl -X GET "http://localhost/debug/historyInfo"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DebugApi;

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

public class DebugApiExample {

    public static void main(String[] args) {
        
        DebugApi apiInstance = new DebugApi();
        try {
            apiInstance.historyInfo();
        } catch (ApiException e) {
            System.err.println("Exception when calling DebugApi#historyInfo");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DebugApi;

public class DebugApiExample {

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

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

// State
[apiInstance historyInfoWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var WavesFullNode = require('waves_full_node');

var api = new WavesFullNode.DebugApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.historyInfo(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class historyInfoExample
    {
        public void main()
        {
            
            var apiInstance = new DebugApi();

            try
            {
                // State
                apiInstance.historyInfo();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DebugApi.historyInfo: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DebugApi();

try {
    $api_instance->historyInfo();
} catch (Exception $e) {
    echo 'Exception when calling DebugApi->historyInfo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DebugApi;

my $api_instance = WWW::SwaggerClient::DebugApi->new();

eval { 
    $api_instance->historyInfo();
};
if ($@) {
    warn "Exception when calling DebugApi->historyInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DebugApi()

try: 
    # State
    api_instance.history_info()
except ApiException as e:
    print("Exception when calling DebugApi->historyInfo: %s\n" % e)

Parameters

Responses

Status: 200 - Json state


minerInfo

State