Phantasma API

Account

apiV1GetAccountGet

Returns the account name and balance of given address.


/api/v1/GetAccount

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAccount?account="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountApi;

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        String account = account_example; // String | 
        try {
            AccountResult result = apiInstance.apiV1GetAccountGet(account);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1GetAccountGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String account = account_example; // String | 
        try {
            AccountResult result = apiInstance.apiV1GetAccountGet(account);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1GetAccountGet");
            e.printStackTrace();
        }
    }
}
String *account = account_example; //  (optional)

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

[apiInstance apiV1GetAccountGetWith:account
              completionHandler: ^(AccountResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AccountApi()
var opts = { 
  'account': account_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAccountGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAccountGetExample
    {
        public void main()
        {

            var apiInstance = new AccountApi();
            var account = account_example;  // String |  (optional) 

            try
            {
                AccountResult result = apiInstance.apiV1GetAccountGet(account);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1GetAccountGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccountApi();
$account = account_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $account = account_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetAccountGet(account => $account);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1GetAccountGet: $@\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.AccountApi()
account = account_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_account_get(account=account)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1GetAccountGet: %s\n" % e)

Parameters

Query parameters
Name Description
account
String

Responses

Status: 200 - Success


apiV1GetAccountsGet

Returns data about several accounts.


/api/v1/GetAccounts

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAccounts?accountText="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountApi;

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        String accountText = accountText_example; // String | 
        try {
            array[AccountResult] result = apiInstance.apiV1GetAccountsGet(accountText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1GetAccountsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String accountText = accountText_example; // String | 
        try {
            array[AccountResult] result = apiInstance.apiV1GetAccountsGet(accountText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1GetAccountsGet");
            e.printStackTrace();
        }
    }
}
String *accountText = accountText_example; //  (optional)

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

[apiInstance apiV1GetAccountsGetWith:accountText
              completionHandler: ^(array[AccountResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AccountApi()
var opts = { 
  'accountText': accountText_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAccountsGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAccountsGetExample
    {
        public void main()
        {

            var apiInstance = new AccountApi();
            var accountText = accountText_example;  // String |  (optional) 

            try
            {
                array[AccountResult] result = apiInstance.apiV1GetAccountsGet(accountText);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1GetAccountsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccountApi();
$accountText = accountText_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $accountText = accountText_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetAccountsGet(accountText => $accountText);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1GetAccountsGet: $@\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.AccountApi()
accountText = accountText_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_accounts_get(accountText=accountText)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1GetAccountsGet: %s\n" % e)

Parameters

Query parameters
Name Description
accountText
String

Responses

Status: 200 - Success


apiV1LookUpNameGet

Returns the address that owns a given name.


/api/v1/LookUpName

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/LookUpName?name="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountApi;

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

public class AccountApiExample {

    public static void main(String[] args) {
        
        AccountApi apiInstance = new AccountApi();
        String name = name_example; // String | 
        try {
            'String' result = apiInstance.apiV1LookUpNameGet(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1LookUpNameGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String name = name_example; // String | 
        try {
            'String' result = apiInstance.apiV1LookUpNameGet(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiV1LookUpNameGet");
            e.printStackTrace();
        }
    }
}
String *name = name_example; //  (optional)

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

[apiInstance apiV1LookUpNameGetWith:name
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AccountApi()
var opts = { 
  'name': name_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1LookUpNameGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1LookUpNameGetExample
    {
        public void main()
        {

            var apiInstance = new AccountApi();
            var name = name_example;  // String |  (optional) 

            try
            {
                'String' result = apiInstance.apiV1LookUpNameGet(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiV1LookUpNameGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAccountApi();
$name = name_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->apiV1LookUpNameGet(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountApi->apiV1LookUpNameGet: $@\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.AccountApi()
name = name_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_look_up_name_get(name=name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->apiV1LookUpNameGet: %s\n" % e)

Parameters

Query parameters
Name Description
name
String

Responses

Status: 200 - Success


Auction

apiV1GetAuctionGet

Returns the number of active auctions.


/api/v1/GetAuction

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAuction?chainAddressOrName=&symbol=&IDtext="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuctionApi;

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

public class AuctionApiExample {

    public static void main(String[] args) {
        
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        try {
            AuctionResult result = apiInstance.apiV1GetAuctionGet(chainAddressOrName, symbol, iDtext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuctionApi;

public class AuctionApiExample {

    public static void main(String[] args) {
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        try {
            AuctionResult result = apiInstance.apiV1GetAuctionGet(chainAddressOrName, symbol, iDtext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *symbol = symbol_example; //  (optional)
String *iDtext = iDtext_example; //  (optional)

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

[apiInstance apiV1GetAuctionGetWith:chainAddressOrName
    symbol:symbol
    iDtext:iDtext
              completionHandler: ^(AuctionResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AuctionApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'symbol': symbol_example, // {{String}} 
  'iDtext': iDtext_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAuctionGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAuctionGetExample
    {
        public void main()
        {

            var apiInstance = new AuctionApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var symbol = symbol_example;  // String |  (optional) 
            var iDtext = iDtext_example;  // String |  (optional) 

            try
            {
                AuctionResult result = apiInstance.apiV1GetAuctionGet(chainAddressOrName, symbol, iDtext);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuctionApi.apiV1GetAuctionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAuctionApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$symbol = symbol_example; // String | 
$iDtext = iDtext_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AuctionApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $symbol = symbol_example; # String | 
my $iDtext = iDtext_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetAuctionGet(chainAddressOrName => $chainAddressOrName, symbol => $symbol, iDtext => $iDtext);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuctionApi->apiV1GetAuctionGet: $@\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.AuctionApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
symbol = symbol_example # String |  (optional)
iDtext = iDtext_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_auction_get(chainAddressOrName=chainAddressOrName, symbol=symbol, iDtext=iDtext)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuctionApi->apiV1GetAuctionGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
symbol
String
IDtext
String

Responses

Status: 200 - Success


apiV1GetAuctionsCountGet

Returns the auctions available in the market.


/api/v1/GetAuctionsCount

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAuctionsCount?chainAddressOrName=&symbol="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuctionApi;

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

public class AuctionApiExample {

    public static void main(String[] args) {
        
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetAuctionsCountGet(chainAddressOrName, symbol);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionsCountGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuctionApi;

public class AuctionApiExample {

    public static void main(String[] args) {
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetAuctionsCountGet(chainAddressOrName, symbol);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionsCountGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *symbol = symbol_example; //  (optional)

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

[apiInstance apiV1GetAuctionsCountGetWith:chainAddressOrName
    symbol:symbol
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AuctionApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'symbol': symbol_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAuctionsCountGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAuctionsCountGetExample
    {
        public void main()
        {

            var apiInstance = new AuctionApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var symbol = symbol_example;  // String |  (optional) 

            try
            {
                'Integer' result = apiInstance.apiV1GetAuctionsCountGet(chainAddressOrName, symbol);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuctionApi.apiV1GetAuctionsCountGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAuctionApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$symbol = symbol_example; // String | 

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

my $api_instance = WWW::SwaggerClient::AuctionApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $symbol = symbol_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetAuctionsCountGet(chainAddressOrName => $chainAddressOrName, symbol => $symbol);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuctionApi->apiV1GetAuctionsCountGet: $@\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.AuctionApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
symbol = symbol_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_auctions_count_get(chainAddressOrName=chainAddressOrName, symbol=symbol)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuctionApi->apiV1GetAuctionsCountGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
symbol
String

Responses

Status: 200 - Success


apiV1GetAuctionsGet

Returns the auction for a specific token.


/api/v1/GetAuctions

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAuctions?chainAddressOrName=&symbol=&page=&pageSize="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuctionApi;

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

public class AuctionApiExample {

    public static void main(String[] args) {
        
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        Integer page = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        try {
            PaginatedResult result = apiInstance.apiV1GetAuctionsGet(chainAddressOrName, symbol, page, pageSize);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuctionApi;

public class AuctionApiExample {

    public static void main(String[] args) {
        AuctionApi apiInstance = new AuctionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String symbol = symbol_example; // String | 
        Integer page = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        try {
            PaginatedResult result = apiInstance.apiV1GetAuctionsGet(chainAddressOrName, symbol, page, pageSize);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuctionApi#apiV1GetAuctionsGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *symbol = symbol_example; //  (optional)
Integer *page = 56; //  (optional) (default to 1)
Integer *pageSize = 56; //  (optional) (default to 99999)

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

[apiInstance apiV1GetAuctionsGetWith:chainAddressOrName
    symbol:symbol
    page:page
    pageSize:pageSize
              completionHandler: ^(PaginatedResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.AuctionApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'symbol': symbol_example, // {{String}} 
  'page': 56, // {{Integer}} 
  'pageSize': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAuctionsGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAuctionsGetExample
    {
        public void main()
        {

            var apiInstance = new AuctionApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var symbol = symbol_example;  // String |  (optional) 
            var page = 56;  // Integer |  (optional)  (default to 1)
            var pageSize = 56;  // Integer |  (optional)  (default to 99999)

            try
            {
                PaginatedResult result = apiInstance.apiV1GetAuctionsGet(chainAddressOrName, symbol, page, pageSize);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuctionApi.apiV1GetAuctionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiAuctionApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$symbol = symbol_example; // String | 
$page = 56; // Integer | 
$pageSize = 56; // Integer | 

try {
    $result = $api_instance->apiV1GetAuctionsGet($chainAddressOrName, $symbol, $page, $pageSize);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuctionApi->apiV1GetAuctionsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuctionApi;

my $api_instance = WWW::SwaggerClient::AuctionApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $symbol = symbol_example; # String | 
my $page = 56; # Integer | 
my $pageSize = 56; # Integer | 

eval { 
    my $result = $api_instance->apiV1GetAuctionsGet(chainAddressOrName => $chainAddressOrName, symbol => $symbol, page => $page, pageSize => $pageSize);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuctionApi->apiV1GetAuctionsGet: $@\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.AuctionApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
symbol = symbol_example # String |  (optional)
page = 56 # Integer |  (optional) (default to 1)
pageSize = 56 # Integer |  (optional) (default to 99999)

try: 
    api_response = api_instance.api_v1_get_auctions_get(chainAddressOrName=chainAddressOrName, symbol=symbol, page=page, pageSize=pageSize)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuctionApi->apiV1GetAuctionsGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
symbol
String
page
Integer (int32)
pageSize
Integer (int32)

Responses

Status: 200 - Success


Block

apiV1GetBlockByHashGet

Returns information about a block by hash.


/api/v1/GetBlockByHash

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetBlockByHash?blockHash="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String blockHash = blockHash_example; // String | 
        try {
            BlockResult result = apiInstance.apiV1GetBlockByHashGet(blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockByHashGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String blockHash = blockHash_example; // String | 
        try {
            BlockResult result = apiInstance.apiV1GetBlockByHashGet(blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockByHashGet");
            e.printStackTrace();
        }
    }
}
String *blockHash = blockHash_example; //  (optional)

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

[apiInstance apiV1GetBlockByHashGetWith:blockHash
              completionHandler: ^(BlockResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'blockHash': blockHash_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetBlockByHashGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetBlockByHashGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var blockHash = blockHash_example;  // String |  (optional) 

            try
            {
                BlockResult result = apiInstance.apiV1GetBlockByHashGet(blockHash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlockApi.apiV1GetBlockByHashGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiBlockApi();
$blockHash = blockHash_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $blockHash = blockHash_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetBlockByHashGet(blockHash => $blockHash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetBlockByHashGet: $@\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.BlockApi()
blockHash = blockHash_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_block_by_hash_get(blockHash=blockHash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetBlockByHashGet: %s\n" % e)

Parameters

Query parameters
Name Description
blockHash
String

Responses

Status: 200 - Success


apiV1GetBlockByHeightGet

Returns information about a block by height and chain.


/api/v1/GetBlockByHeight

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetBlockByHeight?chainInput=&height="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        String height = height_example; // String | 
        try {
            BlockResult result = apiInstance.apiV1GetBlockByHeightGet(chainInput, height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockByHeightGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        String height = height_example; // String | 
        try {
            BlockResult result = apiInstance.apiV1GetBlockByHeightGet(chainInput, height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockByHeightGet");
            e.printStackTrace();
        }
    }
}
String *chainInput = chainInput_example; //  (optional)
String *height = height_example; //  (optional)

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

[apiInstance apiV1GetBlockByHeightGetWith:chainInput
    height:height
              completionHandler: ^(BlockResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'chainInput': chainInput_example, // {{String}} 
  'height': height_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetBlockByHeightGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetBlockByHeightGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var chainInput = chainInput_example;  // String |  (optional) 
            var height = height_example;  // String |  (optional) 

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

$api_instance = new Swagger\Client\ApiBlockApi();
$chainInput = chainInput_example; // String | 
$height = height_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $chainInput = chainInput_example; # String | 
my $height = height_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetBlockByHeightGet(chainInput => $chainInput, height => $height);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetBlockByHeightGet: $@\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.BlockApi()
chainInput = chainInput_example # String |  (optional)
height = height_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_block_by_height_get(chainInput=chainInput, height=height)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetBlockByHeightGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainInput
String
height
String

Responses

Status: 200 - Success


apiV1GetBlockHeightGet

Returns the height of a chain.


/api/v1/GetBlockHeight

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetBlockHeight?chainInput="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetBlockHeightGet(chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockHeightGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetBlockHeightGet(chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockHeightGet");
            e.printStackTrace();
        }
    }
}
String *chainInput = chainInput_example; //  (optional)

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

[apiInstance apiV1GetBlockHeightGetWith:chainInput
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'chainInput': chainInput_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetBlockHeightGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetBlockHeightGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var chainInput = chainInput_example;  // String |  (optional) 

            try
            {
                'String' result = apiInstance.apiV1GetBlockHeightGet(chainInput);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlockApi.apiV1GetBlockHeightGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiBlockApi();
$chainInput = chainInput_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $chainInput = chainInput_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetBlockHeightGet(chainInput => $chainInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetBlockHeightGet: $@\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.BlockApi()
chainInput = chainInput_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_block_height_get(chainInput=chainInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetBlockHeightGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainInput
String

Responses

Status: 200 - Success


apiV1GetBlockTransactionCountByHashGet

Returns the number of transactions of given block hash or error if given hash is invalid or is not found.


/api/v1/GetBlockTransactionCountByHash

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetBlockTransactionCountByHash?chainAddressOrName=&blockHash="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String blockHash = blockHash_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetBlockTransactionCountByHashGet(chainAddressOrName, blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockTransactionCountByHashGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String blockHash = blockHash_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetBlockTransactionCountByHashGet(chainAddressOrName, blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetBlockTransactionCountByHashGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *blockHash = blockHash_example; //  (optional)

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

[apiInstance apiV1GetBlockTransactionCountByHashGetWith:chainAddressOrName
    blockHash:blockHash
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'blockHash': blockHash_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetBlockTransactionCountByHashGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetBlockTransactionCountByHashGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var blockHash = blockHash_example;  // String |  (optional) 

            try
            {
                'Integer' result = apiInstance.apiV1GetBlockTransactionCountByHashGet(chainAddressOrName, blockHash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlockApi.apiV1GetBlockTransactionCountByHashGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiBlockApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$blockHash = blockHash_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $blockHash = blockHash_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetBlockTransactionCountByHashGet(chainAddressOrName => $chainAddressOrName, blockHash => $blockHash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetBlockTransactionCountByHashGet: $@\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.BlockApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
blockHash = blockHash_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_block_transaction_count_by_hash_get(chainAddressOrName=chainAddressOrName, blockHash=blockHash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetBlockTransactionCountByHashGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
blockHash
String

Responses

Status: 200 - Success


apiV1GetRawBlockByHashGet

Returns a serialized string, containing information about a block by hash.


/api/v1/GetRawBlockByHash

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetRawBlockByHash?blockHash="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String blockHash = blockHash_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetRawBlockByHashGet(blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetRawBlockByHashGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String blockHash = blockHash_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetRawBlockByHashGet(blockHash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetRawBlockByHashGet");
            e.printStackTrace();
        }
    }
}
String *blockHash = blockHash_example; //  (optional)

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

[apiInstance apiV1GetRawBlockByHashGetWith:blockHash
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'blockHash': blockHash_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetRawBlockByHashGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetRawBlockByHashGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var blockHash = blockHash_example;  // String |  (optional) 

            try
            {
                'String' result = apiInstance.apiV1GetRawBlockByHashGet(blockHash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlockApi.apiV1GetRawBlockByHashGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiBlockApi();
$blockHash = blockHash_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $blockHash = blockHash_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetRawBlockByHashGet(blockHash => $blockHash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetRawBlockByHashGet: $@\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.BlockApi()
blockHash = blockHash_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_raw_block_by_hash_get(blockHash=blockHash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetRawBlockByHashGet: %s\n" % e)

Parameters

Query parameters
Name Description
blockHash
String

Responses

Status: 200 - Success


apiV1GetRawBlockByHeightGet

Returns a serialized string, in hex format, containing information about a block by height and chain.


/api/v1/GetRawBlockByHeight

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetRawBlockByHeight?chainInput=&height="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BlockApi;

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

public class BlockApiExample {

    public static void main(String[] args) {
        
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        String height = height_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetRawBlockByHeightGet(chainInput, height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetRawBlockByHeightGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.BlockApi;

public class BlockApiExample {

    public static void main(String[] args) {
        BlockApi apiInstance = new BlockApi();
        String chainInput = chainInput_example; // String | 
        String height = height_example; // String | 
        try {
            'String' result = apiInstance.apiV1GetRawBlockByHeightGet(chainInput, height);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlockApi#apiV1GetRawBlockByHeightGet");
            e.printStackTrace();
        }
    }
}
String *chainInput = chainInput_example; //  (optional)
String *height = height_example; //  (optional)

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

[apiInstance apiV1GetRawBlockByHeightGetWith:chainInput
    height:height
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.BlockApi()
var opts = { 
  'chainInput': chainInput_example, // {{String}} 
  'height': height_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetRawBlockByHeightGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetRawBlockByHeightGetExample
    {
        public void main()
        {

            var apiInstance = new BlockApi();
            var chainInput = chainInput_example;  // String |  (optional) 
            var height = height_example;  // String |  (optional) 

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

$api_instance = new Swagger\Client\ApiBlockApi();
$chainInput = chainInput_example; // String | 
$height = height_example; // String | 

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

my $api_instance = WWW::SwaggerClient::BlockApi->new();
my $chainInput = chainInput_example; # String | 
my $height = height_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetRawBlockByHeightGet(chainInput => $chainInput, height => $height);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlockApi->apiV1GetRawBlockByHeightGet: $@\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.BlockApi()
chainInput = chainInput_example # String |  (optional)
height = height_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_raw_block_by_height_get(chainInput=chainInput, height=height)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlockApi->apiV1GetRawBlockByHeightGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainInput
String
height
String

Responses

Status: 200 - Success


Chain

apiV1GetChainsGet

Returns an array of all chains deployed in Phantasma.


/api/v1/GetChains

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetChains"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ChainApi;

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

public class ChainApiExample {

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

public class ChainApiExample {

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

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

[apiInstance apiV1GetChainsGetWithCompletionHandler: 
              ^(array[ChainResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

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

namespace Example
{
    public class apiV1GetChainsGetExample
    {
        public void main()
        {

            var apiInstance = new ChainApi();

            try
            {
                array[ChainResult] result = apiInstance.apiV1GetChainsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ChainApi.apiV1GetChainsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiChainApi();

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

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

eval { 
    my $result = $api_instance->apiV1GetChainsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ChainApi->apiV1GetChainsGet: $@\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.ChainApi()

try: 
    api_response = api_instance.api_v1_get_chains_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ChainApi->apiV1GetChainsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Success


Contract

apiV1GetContractGet

Returns the ABI interface of specific contract.


/api/v1/GetContract

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetContract?chainAddressOrName=&contractName="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContractApi;

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

public class ContractApiExample {

    public static void main(String[] args) {
        
        ContractApi apiInstance = new ContractApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String contractName = contractName_example; // String | 
        try {
            ContractResult result = apiInstance.apiV1GetContractGet(chainAddressOrName, contractName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContractApi#apiV1GetContractGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContractApi;

public class ContractApiExample {

    public static void main(String[] args) {
        ContractApi apiInstance = new ContractApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String contractName = contractName_example; // String | 
        try {
            ContractResult result = apiInstance.apiV1GetContractGet(chainAddressOrName, contractName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContractApi#apiV1GetContractGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *contractName = contractName_example; //  (optional)

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

[apiInstance apiV1GetContractGetWith:chainAddressOrName
    contractName:contractName
              completionHandler: ^(ContractResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.ContractApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'contractName': contractName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetContractGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetContractGetExample
    {
        public void main()
        {

            var apiInstance = new ContractApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var contractName = contractName_example;  // String |  (optional) 

            try
            {
                ContractResult result = apiInstance.apiV1GetContractGet(chainAddressOrName, contractName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContractApi.apiV1GetContractGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiContractApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$contractName = contractName_example; // String | 

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

my $api_instance = WWW::SwaggerClient::ContractApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $contractName = contractName_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetContractGet(chainAddressOrName => $chainAddressOrName, contractName => $contractName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContractApi->apiV1GetContractGet: $@\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.ContractApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
contractName = contractName_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_contract_get(chainAddressOrName=chainAddressOrName, contractName=contractName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContractApi->apiV1GetContractGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
contractName
String

Responses

Status: 200 - Success


Leaderboard

apiV1GetLeaderboardGet

Returns content of a Phantasma leaderboard.


/api/v1/GetLeaderboard

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetLeaderboard?name="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LeaderboardApi;

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

public class LeaderboardApiExample {

    public static void main(String[] args) {
        
        LeaderboardApi apiInstance = new LeaderboardApi();
        String name = name_example; // String | 
        try {
            LeaderboardResult result = apiInstance.apiV1GetLeaderboardGet(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LeaderboardApi#apiV1GetLeaderboardGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LeaderboardApi;

public class LeaderboardApiExample {

    public static void main(String[] args) {
        LeaderboardApi apiInstance = new LeaderboardApi();
        String name = name_example; // String | 
        try {
            LeaderboardResult result = apiInstance.apiV1GetLeaderboardGet(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LeaderboardApi#apiV1GetLeaderboardGet");
            e.printStackTrace();
        }
    }
}
String *name = name_example; //  (optional)

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

[apiInstance apiV1GetLeaderboardGetWith:name
              completionHandler: ^(LeaderboardResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.LeaderboardApi()
var opts = { 
  'name': name_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetLeaderboardGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetLeaderboardGetExample
    {
        public void main()
        {

            var apiInstance = new LeaderboardApi();
            var name = name_example;  // String |  (optional) 

            try
            {
                LeaderboardResult result = apiInstance.apiV1GetLeaderboardGet(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LeaderboardApi.apiV1GetLeaderboardGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiLeaderboardApi();
$name = name_example; // String | 

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

my $api_instance = WWW::SwaggerClient::LeaderboardApi->new();
my $name = name_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetLeaderboardGet(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LeaderboardApi->apiV1GetLeaderboardGet: $@\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.LeaderboardApi()
name = name_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_leaderboard_get(name=name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LeaderboardApi->apiV1GetLeaderboardGet: %s\n" % e)

Parameters

Query parameters
Name Description
name
String

Responses

Status: 200 - Success


Nexus

apiV1GetNexusGet

Returns info about the nexus.


/api/v1/GetNexus

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetNexus?extended="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NexusApi;

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

public class NexusApiExample {

    public static void main(String[] args) {
        
        NexusApi apiInstance = new NexusApi();
        Boolean extended = true; // Boolean | 
        try {
            NexusResult result = apiInstance.apiV1GetNexusGet(extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NexusApi#apiV1GetNexusGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NexusApi;

public class NexusApiExample {

    public static void main(String[] args) {
        NexusApi apiInstance = new NexusApi();
        Boolean extended = true; // Boolean | 
        try {
            NexusResult result = apiInstance.apiV1GetNexusGet(extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NexusApi#apiV1GetNexusGet");
            e.printStackTrace();
        }
    }
}
Boolean *extended = true; //  (optional) (default to false)

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

[apiInstance apiV1GetNexusGetWith:extended
              completionHandler: ^(NexusResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.NexusApi()
var opts = { 
  'extended': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetNexusGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetNexusGetExample
    {
        public void main()
        {

            var apiInstance = new NexusApi();
            var extended = true;  // Boolean |  (optional)  (default to false)

            try
            {
                NexusResult result = apiInstance.apiV1GetNexusGet(extended);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NexusApi.apiV1GetNexusGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiNexusApi();
$extended = true; // Boolean | 

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

my $api_instance = WWW::SwaggerClient::NexusApi->new();
my $extended = true; # Boolean | 

eval { 
    my $result = $api_instance->apiV1GetNexusGet(extended => $extended);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NexusApi->apiV1GetNexusGet: $@\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.NexusApi()
extended = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.api_v1_get_nexus_get(extended=extended)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NexusApi->apiV1GetNexusGet: %s\n" % e)

Parameters

Query parameters
Name Description
extended
Boolean

Responses

Status: 200 - Success


Organization

apiV1GetOrganizationGet

Returns info about an organization.


/api/v1/GetOrganization

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetOrganization?ID="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrganizationApi;

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

public class OrganizationApiExample {

    public static void main(String[] args) {
        
        OrganizationApi apiInstance = new OrganizationApi();
        String iD = iD_example; // String | 
        try {
            OrganizationResult result = apiInstance.apiV1GetOrganizationGet(iD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrganizationApi#apiV1GetOrganizationGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrganizationApi;

public class OrganizationApiExample {

    public static void main(String[] args) {
        OrganizationApi apiInstance = new OrganizationApi();
        String iD = iD_example; // String | 
        try {
            OrganizationResult result = apiInstance.apiV1GetOrganizationGet(iD);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrganizationApi#apiV1GetOrganizationGet");
            e.printStackTrace();
        }
    }
}
String *iD = iD_example; //  (optional)

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

[apiInstance apiV1GetOrganizationGetWith:iD
              completionHandler: ^(OrganizationResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.OrganizationApi()
var opts = { 
  'iD': iD_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetOrganizationGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetOrganizationGetExample
    {
        public void main()
        {

            var apiInstance = new OrganizationApi();
            var iD = iD_example;  // String |  (optional) 

            try
            {
                OrganizationResult result = apiInstance.apiV1GetOrganizationGet(iD);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrganizationApi.apiV1GetOrganizationGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOrganizationApi();
$iD = iD_example; // String | 

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

my $api_instance = WWW::SwaggerClient::OrganizationApi->new();
my $iD = iD_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetOrganizationGet(iD => $iD);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrganizationApi->apiV1GetOrganizationGet: $@\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.OrganizationApi()
iD = iD_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_organization_get(iD=iD)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrganizationApi->apiV1GetOrganizationGet: %s\n" % e)

Parameters

Query parameters
Name Description
ID
String

Responses

Status: 200 - Success


Platform

apiV1GetPlatformsGet

Returns an array of available interop platforms.


/api/v1/GetPlatforms

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetPlatforms"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PlatformApi;

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

public class PlatformApiExample {

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

public class PlatformApiExample {

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

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

[apiInstance apiV1GetPlatformsGetWithCompletionHandler: 
              ^(array[PlatformResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

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

namespace Example
{
    public class apiV1GetPlatformsGetExample
    {
        public void main()
        {

            var apiInstance = new PlatformApi();

            try
            {
                array[PlatformResult] result = apiInstance.apiV1GetPlatformsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PlatformApi.apiV1GetPlatformsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPlatformApi();

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

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

eval { 
    my $result = $api_instance->apiV1GetPlatformsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlatformApi->apiV1GetPlatformsGet: $@\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.PlatformApi()

try: 
    api_response = api_instance.api_v1_get_platforms_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlatformApi->apiV1GetPlatformsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Success


Rpc

rpcPost

Returns query result.


/rpc

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json,text/json,application/*+json"\
"//rpc"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.RpcApi;

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

public class RpcApiExample {

    public static void main(String[] args) {
        
        RpcApi apiInstance = new RpcApi();
        RpcRequest body = ; // RpcRequest | 
        try {
            RpcResponse result = apiInstance.rpcPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RpcApi#rpcPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.RpcApi;

public class RpcApiExample {

    public static void main(String[] args) {
        RpcApi apiInstance = new RpcApi();
        RpcRequest body = ; // RpcRequest | 
        try {
            RpcResponse result = apiInstance.rpcPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RpcApi#rpcPost");
            e.printStackTrace();
        }
    }
}
RpcRequest *body = ; //  (optional)

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

[apiInstance rpcPostWith:body
              completionHandler: ^(RpcResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

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

namespace Example
{
    public class rpcPostExample
    {
        public void main()
        {

            var apiInstance = new RpcApi();
            var body = new RpcRequest(); // RpcRequest |  (optional) 

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

$api_instance = new Swagger\Client\ApiRpcApi();
$body = ; // RpcRequest | 

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

my $api_instance = WWW::SwaggerClient::RpcApi->new();
my $body = WWW::SwaggerClient::Object::RpcRequest->new(); # RpcRequest | 

eval { 
    my $result = $api_instance->rpcPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RpcApi->rpcPost: $@\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.RpcApi()
body =  # RpcRequest |  (optional)

try: 
    api_response = api_instance.rpc_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RpcApi->rpcPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success


Sale

apiV1GetLatestSaleHashGet

"Returns latest sale hash.


/api/v1/GetLatestSaleHash

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetLatestSaleHash"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SaleApi;

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

public class SaleApiExample {

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

public class SaleApiExample {

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

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

[apiInstance apiV1GetLatestSaleHashGetWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

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

namespace Example
{
    public class apiV1GetLatestSaleHashGetExample
    {
        public void main()
        {

            var apiInstance = new SaleApi();

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

$api_instance = new Swagger\Client\ApiSaleApi();

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

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

eval { 
    my $result = $api_instance->apiV1GetLatestSaleHashGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SaleApi->apiV1GetLatestSaleHashGet: $@\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.SaleApi()

try: 
    api_response = api_instance.api_v1_get_latest_sale_hash_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SaleApi->apiV1GetLatestSaleHashGet: %s\n" % e)

Parameters

Responses

Status: 200 - Success


apiV1GetSaleGet

Returns data about a crowdsale.


/api/v1/GetSale

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetSale?hashText="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SaleApi;

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

public class SaleApiExample {

    public static void main(String[] args) {
        
        SaleApi apiInstance = new SaleApi();
        String hashText = hashText_example; // String | 
        try {
            CrowdsaleResult result = apiInstance.apiV1GetSaleGet(hashText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SaleApi#apiV1GetSaleGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SaleApi;

public class SaleApiExample {

    public static void main(String[] args) {
        SaleApi apiInstance = new SaleApi();
        String hashText = hashText_example; // String | 
        try {
            CrowdsaleResult result = apiInstance.apiV1GetSaleGet(hashText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SaleApi#apiV1GetSaleGet");
            e.printStackTrace();
        }
    }
}
String *hashText = hashText_example; //  (optional)

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

[apiInstance apiV1GetSaleGetWith:hashText
              completionHandler: ^(CrowdsaleResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.SaleApi()
var opts = { 
  'hashText': hashText_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetSaleGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetSaleGetExample
    {
        public void main()
        {

            var apiInstance = new SaleApi();
            var hashText = hashText_example;  // String |  (optional) 

            try
            {
                CrowdsaleResult result = apiInstance.apiV1GetSaleGet(hashText);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SaleApi.apiV1GetSaleGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSaleApi();
$hashText = hashText_example; // String | 

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

my $api_instance = WWW::SwaggerClient::SaleApi->new();
my $hashText = hashText_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetSaleGet(hashText => $hashText);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SaleApi->apiV1GetSaleGet: $@\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.SaleApi()
hashText = hashText_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_sale_get(hashText=hashText)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SaleApi->apiV1GetSaleGet: %s\n" % e)

Parameters

Query parameters
Name Description
hashText
String

Responses

Status: 200 - Success


Token

apiV1GetNFTGet

Returns data of a non-fungible token, in hexadecimal format.


/api/v1/GetNFT

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetNFT?symbol=&IDtext=&extended="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            TokenDataResult result = apiInstance.apiV1GetNFTGet(symbol, iDtext, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetNFTGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            TokenDataResult result = apiInstance.apiV1GetNFTGet(symbol, iDtext, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetNFTGet");
            e.printStackTrace();
        }
    }
}
String *symbol = symbol_example; //  (optional)
String *iDtext = iDtext_example; //  (optional)
Boolean *extended = true; //  (optional) (default to false)

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

[apiInstance apiV1GetNFTGetWith:symbol
    iDtext:iDtext
    extended:extended
              completionHandler: ^(TokenDataResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'symbol': symbol_example, // {{String}} 
  'iDtext': iDtext_example, // {{String}} 
  'extended': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetNFTGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetNFTGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var symbol = symbol_example;  // String |  (optional) 
            var iDtext = iDtext_example;  // String |  (optional) 
            var extended = true;  // Boolean |  (optional)  (default to false)

            try
            {
                TokenDataResult result = apiInstance.apiV1GetNFTGet(symbol, iDtext, extended);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetNFTGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$symbol = symbol_example; // String | 
$iDtext = iDtext_example; // String | 
$extended = true; // Boolean | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $symbol = symbol_example; # String | 
my $iDtext = iDtext_example; # String | 
my $extended = true; # Boolean | 

eval { 
    my $result = $api_instance->apiV1GetNFTGet(symbol => $symbol, iDtext => $iDtext, extended => $extended);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetNFTGet: $@\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.TokenApi()
symbol = symbol_example # String |  (optional)
iDtext = iDtext_example # String |  (optional)
extended = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.api_v1_get_nft_get(symbol=symbol, iDtext=iDtext, extended=extended)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetNFTGet: %s\n" % e)

Parameters

Query parameters
Name Description
symbol
String
IDtext
String
extended
Boolean

Responses

Status: 200 - Success


apiV1GetNFTsGet

Returns an array of NFTs.


/api/v1/GetNFTs

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetNFTs?symbol=&IDText=&extended="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDText = iDText_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            array[TokenDataResult] result = apiInstance.apiV1GetNFTsGet(symbol, iDText, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetNFTsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDText = iDText_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            array[TokenDataResult] result = apiInstance.apiV1GetNFTsGet(symbol, iDText, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetNFTsGet");
            e.printStackTrace();
        }
    }
}
String *symbol = symbol_example; //  (optional)
String *iDText = iDText_example; //  (optional)
Boolean *extended = true; //  (optional) (default to false)

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

[apiInstance apiV1GetNFTsGetWith:symbol
    iDText:iDText
    extended:extended
              completionHandler: ^(array[TokenDataResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'symbol': symbol_example, // {{String}} 
  'iDText': iDText_example, // {{String}} 
  'extended': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetNFTsGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetNFTsGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var symbol = symbol_example;  // String |  (optional) 
            var iDText = iDText_example;  // String |  (optional) 
            var extended = true;  // Boolean |  (optional)  (default to false)

            try
            {
                array[TokenDataResult] result = apiInstance.apiV1GetNFTsGet(symbol, iDText, extended);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetNFTsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$symbol = symbol_example; // String | 
$iDText = iDText_example; // String | 
$extended = true; // Boolean | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $symbol = symbol_example; # String | 
my $iDText = iDText_example; # String | 
my $extended = true; # Boolean | 

eval { 
    my $result = $api_instance->apiV1GetNFTsGet(symbol => $symbol, iDText => $iDText, extended => $extended);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetNFTsGet: $@\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.TokenApi()
symbol = symbol_example # String |  (optional)
iDText = iDText_example # String |  (optional)
extended = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.api_v1_get_nfts_get(symbol=symbol, iDText=iDText, extended=extended)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetNFTsGet: %s\n" % e)

Parameters

Query parameters
Name Description
symbol
String
IDText
String
extended
Boolean

Responses

Status: 200 - Success


apiV1GetTokenBalanceGet

Returns the balance for a specific token and chain, given an address.


/api/v1/GetTokenBalance

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetTokenBalance?account=&tokenSymbol=&chainInput="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        String account = account_example; // String | 
        String tokenSymbol = tokenSymbol_example; // String | 
        String chainInput = chainInput_example; // String | 
        try {
            BalanceResult result = apiInstance.apiV1GetTokenBalanceGet(account, tokenSymbol, chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenBalanceGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        String account = account_example; // String | 
        String tokenSymbol = tokenSymbol_example; // String | 
        String chainInput = chainInput_example; // String | 
        try {
            BalanceResult result = apiInstance.apiV1GetTokenBalanceGet(account, tokenSymbol, chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenBalanceGet");
            e.printStackTrace();
        }
    }
}
String *account = account_example; //  (optional)
String *tokenSymbol = tokenSymbol_example; //  (optional)
String *chainInput = chainInput_example; //  (optional)

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

[apiInstance apiV1GetTokenBalanceGetWith:account
    tokenSymbol:tokenSymbol
    chainInput:chainInput
              completionHandler: ^(BalanceResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'account': account_example, // {{String}} 
  'tokenSymbol': tokenSymbol_example, // {{String}} 
  'chainInput': chainInput_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTokenBalanceGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTokenBalanceGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var account = account_example;  // String |  (optional) 
            var tokenSymbol = tokenSymbol_example;  // String |  (optional) 
            var chainInput = chainInput_example;  // String |  (optional) 

            try
            {
                BalanceResult result = apiInstance.apiV1GetTokenBalanceGet(account, tokenSymbol, chainInput);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetTokenBalanceGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$account = account_example; // String | 
$tokenSymbol = tokenSymbol_example; // String | 
$chainInput = chainInput_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $account = account_example; # String | 
my $tokenSymbol = tokenSymbol_example; # String | 
my $chainInput = chainInput_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetTokenBalanceGet(account => $account, tokenSymbol => $tokenSymbol, chainInput => $chainInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetTokenBalanceGet: $@\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.TokenApi()
account = account_example # String |  (optional)
tokenSymbol = tokenSymbol_example # String |  (optional)
chainInput = chainInput_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_token_balance_get(account=account, tokenSymbol=tokenSymbol, chainInput=chainInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetTokenBalanceGet: %s\n" % e)

Parameters

Query parameters
Name Description
account
String
tokenSymbol
String
chainInput
String

Responses

Status: 200 - Success


apiV1GetTokenDataGet

Returns data of a non-fungible token, in hexadecimal format.


/api/v1/GetTokenData

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetTokenData?symbol=&IDtext="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        try {
            TokenDataResult result = apiInstance.apiV1GetTokenDataGet(symbol, iDtext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenDataGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        String iDtext = iDtext_example; // String | 
        try {
            TokenDataResult result = apiInstance.apiV1GetTokenDataGet(symbol, iDtext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenDataGet");
            e.printStackTrace();
        }
    }
}
String *symbol = symbol_example; //  (optional)
String *iDtext = iDtext_example; //  (optional)

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

[apiInstance apiV1GetTokenDataGetWith:symbol
    iDtext:iDtext
              completionHandler: ^(TokenDataResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'symbol': symbol_example, // {{String}} 
  'iDtext': iDtext_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTokenDataGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTokenDataGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var symbol = symbol_example;  // String |  (optional) 
            var iDtext = iDtext_example;  // String |  (optional) 

            try
            {
                TokenDataResult result = apiInstance.apiV1GetTokenDataGet(symbol, iDtext);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetTokenDataGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$symbol = symbol_example; // String | 
$iDtext = iDtext_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $symbol = symbol_example; # String | 
my $iDtext = iDtext_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetTokenDataGet(symbol => $symbol, iDtext => $iDtext);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetTokenDataGet: $@\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.TokenApi()
symbol = symbol_example # String |  (optional)
iDtext = iDtext_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_token_data_get(symbol=symbol, iDtext=iDtext)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetTokenDataGet: %s\n" % e)

Parameters

Query parameters
Name Description
symbol
String
IDtext
String

Responses

Status: 200 - Success


apiV1GetTokenGet

Returns info about a specific token deployed in Phantasma.


/api/v1/GetToken

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetToken?symbol=&extended="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            TokenResult result = apiInstance.apiV1GetTokenGet(symbol, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        String symbol = symbol_example; // String | 
        Boolean extended = true; // Boolean | 
        try {
            TokenResult result = apiInstance.apiV1GetTokenGet(symbol, extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokenGet");
            e.printStackTrace();
        }
    }
}
String *symbol = symbol_example; //  (optional)
Boolean *extended = true; //  (optional) (default to false)

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

[apiInstance apiV1GetTokenGetWith:symbol
    extended:extended
              completionHandler: ^(TokenResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'symbol': symbol_example, // {{String}} 
  'extended': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTokenGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTokenGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var symbol = symbol_example;  // String |  (optional) 
            var extended = true;  // Boolean |  (optional)  (default to false)

            try
            {
                TokenResult result = apiInstance.apiV1GetTokenGet(symbol, extended);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetTokenGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$symbol = symbol_example; // String | 
$extended = true; // Boolean | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $symbol = symbol_example; # String | 
my $extended = true; # Boolean | 

eval { 
    my $result = $api_instance->apiV1GetTokenGet(symbol => $symbol, extended => $extended);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetTokenGet: $@\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.TokenApi()
symbol = symbol_example # String |  (optional)
extended = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.api_v1_get_token_get(symbol=symbol, extended=extended)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetTokenGet: %s\n" % e)

Parameters

Query parameters
Name Description
symbol
String
extended
Boolean

Responses

Status: 200 - Success


apiV1GetTokensGet

Returns an array of tokens deployed in Phantasma.


/api/v1/GetTokens

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetTokens?extended="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TokenApi;

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

public class TokenApiExample {

    public static void main(String[] args) {
        
        TokenApi apiInstance = new TokenApi();
        Boolean extended = true; // Boolean | 
        try {
            array[TokenResult] result = apiInstance.apiV1GetTokensGet(extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokensGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TokenApi;

public class TokenApiExample {

    public static void main(String[] args) {
        TokenApi apiInstance = new TokenApi();
        Boolean extended = true; // Boolean | 
        try {
            array[TokenResult] result = apiInstance.apiV1GetTokensGet(extended);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TokenApi#apiV1GetTokensGet");
            e.printStackTrace();
        }
    }
}
Boolean *extended = true; //  (optional) (default to false)

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

[apiInstance apiV1GetTokensGetWith:extended
              completionHandler: ^(array[TokenResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TokenApi()
var opts = { 
  'extended': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTokensGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTokensGetExample
    {
        public void main()
        {

            var apiInstance = new TokenApi();
            var extended = true;  // Boolean |  (optional)  (default to false)

            try
            {
                array[TokenResult] result = apiInstance.apiV1GetTokensGet(extended);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TokenApi.apiV1GetTokensGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTokenApi();
$extended = true; // Boolean | 

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

my $api_instance = WWW::SwaggerClient::TokenApi->new();
my $extended = true; # Boolean | 

eval { 
    my $result = $api_instance->apiV1GetTokensGet(extended => $extended);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TokenApi->apiV1GetTokensGet: $@\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.TokenApi()
extended = true # Boolean |  (optional) (default to false)

try: 
    api_response = api_instance.api_v1_get_tokens_get(extended=extended)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TokenApi->apiV1GetTokensGet: %s\n" % e)

Parameters

Query parameters
Name Description
extended
Boolean

Responses

Status: 200 - Success


Transaction

apiV1GetAddressTransactionCountGet

Get number of transactions in a specific address and chain


/api/v1/GetAddressTransactionCount

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAddressTransactionCount?account=&chainInput="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String account = account_example; // String | 
        String chainInput = chainInput_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetAddressTransactionCountGet(account, chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetAddressTransactionCountGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String account = account_example; // String | 
        String chainInput = chainInput_example; // String | 
        try {
            'Integer' result = apiInstance.apiV1GetAddressTransactionCountGet(account, chainInput);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetAddressTransactionCountGet");
            e.printStackTrace();
        }
    }
}
String *account = account_example; //  (optional)
String *chainInput = chainInput_example; //  (optional) (default to main)

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

[apiInstance apiV1GetAddressTransactionCountGetWith:account
    chainInput:chainInput
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'account': account_example, // {{String}} 
  'chainInput': chainInput_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAddressTransactionCountGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAddressTransactionCountGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var account = account_example;  // String |  (optional) 
            var chainInput = chainInput_example;  // String |  (optional)  (default to main)

            try
            {
                'Integer' result = apiInstance.apiV1GetAddressTransactionCountGet(account, chainInput);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1GetAddressTransactionCountGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$account = account_example; // String | 
$chainInput = chainInput_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $account = account_example; # String | 
my $chainInput = chainInput_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetAddressTransactionCountGet(account => $account, chainInput => $chainInput);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1GetAddressTransactionCountGet: $@\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.TransactionApi()
account = account_example # String |  (optional)
chainInput = chainInput_example # String |  (optional) (default to main)

try: 
    api_response = api_instance.api_v1_get_address_transaction_count_get(account=account, chainInput=chainInput)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1GetAddressTransactionCountGet: %s\n" % e)

Parameters

Query parameters
Name Description
account
String
chainInput
String

Responses

Status: 200 - Success


apiV1GetAddressTransactionsGet

Returns last X transactions of given address.


/api/v1/GetAddressTransactions

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetAddressTransactions?account=&page=&pageSize="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String account = account_example; // String | 
        Integer page = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        try {
            PaginatedResult result = apiInstance.apiV1GetAddressTransactionsGet(account, page, pageSize);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetAddressTransactionsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String account = account_example; // String | 
        Integer page = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        try {
            PaginatedResult result = apiInstance.apiV1GetAddressTransactionsGet(account, page, pageSize);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetAddressTransactionsGet");
            e.printStackTrace();
        }
    }
}
String *account = account_example; //  (optional)
Integer *page = 56; //  (optional) (default to 1)
Integer *pageSize = 56; //  (optional) (default to 99999)

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

[apiInstance apiV1GetAddressTransactionsGetWith:account
    page:page
    pageSize:pageSize
              completionHandler: ^(PaginatedResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'account': account_example, // {{String}} 
  'page': 56, // {{Integer}} 
  'pageSize': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetAddressTransactionsGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetAddressTransactionsGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var account = account_example;  // String |  (optional) 
            var page = 56;  // Integer |  (optional)  (default to 1)
            var pageSize = 56;  // Integer |  (optional)  (default to 99999)

            try
            {
                PaginatedResult result = apiInstance.apiV1GetAddressTransactionsGet(account, page, pageSize);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1GetAddressTransactionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$account = account_example; // String | 
$page = 56; // Integer | 
$pageSize = 56; // Integer | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $account = account_example; # String | 
my $page = 56; # Integer | 
my $pageSize = 56; # Integer | 

eval { 
    my $result = $api_instance->apiV1GetAddressTransactionsGet(account => $account, page => $page, pageSize => $pageSize);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1GetAddressTransactionsGet: $@\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.TransactionApi()
account = account_example # String |  (optional)
page = 56 # Integer |  (optional) (default to 1)
pageSize = 56 # Integer |  (optional) (default to 99999)

try: 
    api_response = api_instance.api_v1_get_address_transactions_get(account=account, page=page, pageSize=pageSize)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1GetAddressTransactionsGet: %s\n" % e)

Parameters

Query parameters
Name Description
account
String
page
Integer (int32)
pageSize
Integer (int32)

Responses

Status: 200 - Success


apiV1GetTransactionByBlockHashAndIndexGet

Returns the information about a transaction requested by a block hash and transaction index.


/api/v1/GetTransactionByBlockHashAndIndex

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetTransactionByBlockHashAndIndex?chainAddressOrName=&blockHash=&index="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String blockHash = blockHash_example; // String | 
        Integer index = 56; // Integer | 
        try {
            TransactionResult result = apiInstance.apiV1GetTransactionByBlockHashAndIndexGet(chainAddressOrName, blockHash, index);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetTransactionByBlockHashAndIndexGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String chainAddressOrName = chainAddressOrName_example; // String | 
        String blockHash = blockHash_example; // String | 
        Integer index = 56; // Integer | 
        try {
            TransactionResult result = apiInstance.apiV1GetTransactionByBlockHashAndIndexGet(chainAddressOrName, blockHash, index);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetTransactionByBlockHashAndIndexGet");
            e.printStackTrace();
        }
    }
}
String *chainAddressOrName = chainAddressOrName_example; //  (optional)
String *blockHash = blockHash_example; //  (optional)
Integer *index = 56; //  (optional)

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

[apiInstance apiV1GetTransactionByBlockHashAndIndexGetWith:chainAddressOrName
    blockHash:blockHash
    index:index
              completionHandler: ^(TransactionResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'chainAddressOrName': chainAddressOrName_example, // {{String}} 
  'blockHash': blockHash_example, // {{String}} 
  'index': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTransactionByBlockHashAndIndexGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTransactionByBlockHashAndIndexGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var chainAddressOrName = chainAddressOrName_example;  // String |  (optional) 
            var blockHash = blockHash_example;  // String |  (optional) 
            var index = 56;  // Integer |  (optional) 

            try
            {
                TransactionResult result = apiInstance.apiV1GetTransactionByBlockHashAndIndexGet(chainAddressOrName, blockHash, index);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1GetTransactionByBlockHashAndIndexGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$chainAddressOrName = chainAddressOrName_example; // String | 
$blockHash = blockHash_example; // String | 
$index = 56; // Integer | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $chainAddressOrName = chainAddressOrName_example; # String | 
my $blockHash = blockHash_example; # String | 
my $index = 56; # Integer | 

eval { 
    my $result = $api_instance->apiV1GetTransactionByBlockHashAndIndexGet(chainAddressOrName => $chainAddressOrName, blockHash => $blockHash, index => $index);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1GetTransactionByBlockHashAndIndexGet: $@\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.TransactionApi()
chainAddressOrName = chainAddressOrName_example # String |  (optional)
blockHash = blockHash_example # String |  (optional)
index = 56 # Integer |  (optional)

try: 
    api_response = api_instance.api_v1_get_transaction_by_block_hash_and_index_get(chainAddressOrName=chainAddressOrName, blockHash=blockHash, index=index)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1GetTransactionByBlockHashAndIndexGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainAddressOrName
String
blockHash
String
index
Integer (int32)

Responses

Status: 200 - Success


apiV1GetTransactionGet

Returns information about a transaction by hash.


/api/v1/GetTransaction

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetTransaction?hashText="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String hashText = hashText_example; // String | 
        try {
            TransactionResult result = apiInstance.apiV1GetTransactionGet(hashText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetTransactionGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String hashText = hashText_example; // String | 
        try {
            TransactionResult result = apiInstance.apiV1GetTransactionGet(hashText);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1GetTransactionGet");
            e.printStackTrace();
        }
    }
}
String *hashText = hashText_example; //  (optional)

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

[apiInstance apiV1GetTransactionGetWith:hashText
              completionHandler: ^(TransactionResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'hashText': hashText_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1GetTransactionGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1GetTransactionGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var hashText = hashText_example;  // String |  (optional) 

            try
            {
                TransactionResult result = apiInstance.apiV1GetTransactionGet(hashText);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1GetTransactionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$hashText = hashText_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $hashText = hashText_example; # String | 

eval { 
    my $result = $api_instance->apiV1GetTransactionGet(hashText => $hashText);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1GetTransactionGet: $@\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.TransactionApi()
hashText = hashText_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_get_transaction_get(hashText=hashText)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1GetTransactionGet: %s\n" % e)

Parameters

Query parameters
Name Description
hashText
String

Responses

Status: 200 - Success


apiV1InvokeRawScriptGet

Allows to invoke script based on network state, without state changes.


/api/v1/InvokeRawScript

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/InvokeRawScript?chainInput=&scriptData="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String chainInput = chainInput_example; // String | 
        String scriptData = scriptData_example; // String | 
        try {
            ScriptResult result = apiInstance.apiV1InvokeRawScriptGet(chainInput, scriptData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1InvokeRawScriptGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String chainInput = chainInput_example; // String | 
        String scriptData = scriptData_example; // String | 
        try {
            ScriptResult result = apiInstance.apiV1InvokeRawScriptGet(chainInput, scriptData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1InvokeRawScriptGet");
            e.printStackTrace();
        }
    }
}
String *chainInput = chainInput_example; //  (optional)
String *scriptData = scriptData_example; //  (optional)

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

[apiInstance apiV1InvokeRawScriptGetWith:chainInput
    scriptData:scriptData
              completionHandler: ^(ScriptResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'chainInput': chainInput_example, // {{String}} 
  'scriptData': scriptData_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1InvokeRawScriptGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1InvokeRawScriptGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var chainInput = chainInput_example;  // String |  (optional) 
            var scriptData = scriptData_example;  // String |  (optional) 

            try
            {
                ScriptResult result = apiInstance.apiV1InvokeRawScriptGet(chainInput, scriptData);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1InvokeRawScriptGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$chainInput = chainInput_example; // String | 
$scriptData = scriptData_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $chainInput = chainInput_example; # String | 
my $scriptData = scriptData_example; # String | 

eval { 
    my $result = $api_instance->apiV1InvokeRawScriptGet(chainInput => $chainInput, scriptData => $scriptData);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1InvokeRawScriptGet: $@\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.TransactionApi()
chainInput = chainInput_example # String |  (optional)
scriptData = scriptData_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_invoke_raw_script_get(chainInput=chainInput, scriptData=scriptData)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1InvokeRawScriptGet: %s\n" % e)

Parameters

Query parameters
Name Description
chainInput
String
scriptData
String

Responses

Status: 200 - Success


apiV1SendRawTransactionGet

Allows to broadcast a signed operation on the network, but it's required to build it manually.


/api/v1/SendRawTransaction

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/SendRawTransaction?txData="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.TransactionApi;

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

public class TransactionApiExample {

    public static void main(String[] args) {
        
        TransactionApi apiInstance = new TransactionApi();
        String txData = txData_example; // String | 
        try {
            'String' result = apiInstance.apiV1SendRawTransactionGet(txData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1SendRawTransactionGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.TransactionApi;

public class TransactionApiExample {

    public static void main(String[] args) {
        TransactionApi apiInstance = new TransactionApi();
        String txData = txData_example; // String | 
        try {
            'String' result = apiInstance.apiV1SendRawTransactionGet(txData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionApi#apiV1SendRawTransactionGet");
            e.printStackTrace();
        }
    }
}
String *txData = txData_example; //  (optional)

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

[apiInstance apiV1SendRawTransactionGetWith:txData
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

var api = new PhantasmaApi.TransactionApi()
var opts = { 
  'txData': txData_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.apiV1SendRawTransactionGet(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiV1SendRawTransactionGetExample
    {
        public void main()
        {

            var apiInstance = new TransactionApi();
            var txData = txData_example;  // String |  (optional) 

            try
            {
                'String' result = apiInstance.apiV1SendRawTransactionGet(txData);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionApi.apiV1SendRawTransactionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiTransactionApi();
$txData = txData_example; // String | 

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

my $api_instance = WWW::SwaggerClient::TransactionApi->new();
my $txData = txData_example; # String | 

eval { 
    my $result = $api_instance->apiV1SendRawTransactionGet(txData => $txData);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionApi->apiV1SendRawTransactionGet: $@\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.TransactionApi()
txData = txData_example # String |  (optional)

try: 
    api_response = api_instance.api_v1_send_raw_transaction_get(txData=txData)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionApi->apiV1SendRawTransactionGet: %s\n" % e)

Parameters

Query parameters
Name Description
txData
String

Responses

Status: 200 - Success


Validator

apiV1GetValidatorsGet

Returns an array of available validators.


/api/v1/GetValidators

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/GetValidators"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ValidatorApi;

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

public class ValidatorApiExample {

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

public class ValidatorApiExample {

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

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

[apiInstance apiV1GetValidatorsGetWithCompletionHandler: 
              ^(array[ValidatorResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var PhantasmaApi = require('phantasma_api');

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

namespace Example
{
    public class apiV1GetValidatorsGetExample
    {
        public void main()
        {

            var apiInstance = new ValidatorApi();

            try
            {
                array[ValidatorResult] result = apiInstance.apiV1GetValidatorsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ValidatorApi.apiV1GetValidatorsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiValidatorApi();

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

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

eval { 
    my $result = $api_instance->apiV1GetValidatorsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ValidatorApi->apiV1GetValidatorsGet: $@\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.ValidatorApi()

try: 
    api_response = api_instance.api_v1_get_validators_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ValidatorApi->apiV1GetValidatorsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Success