From f027d1f350f7ad0c223008b3131ea75bdddf5ecf Mon Sep 17 00:00:00 2001 From: Olemis Lang Date: Thu, 17 Jan 2019 14:14:55 -0500 Subject: [PATCH 1/7] Branch 0.25.1.dev based on skycoin/skycoin v0.25.0 --- skycoin/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skycoin/__init__.py b/skycoin/__init__.py index ce572cdd..21db169c 100644 --- a/skycoin/__init__.py +++ b/skycoin/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.25.0.post1" +__version__ = "0.25.1.dev" init_error = None def _print2stderr(msg): From 0e630e9274ef15604954ac8ab15600072d37fd06 Mon Sep 17 00:00:00 2001 From: Marcos Antonio Maceo Reyes Date: Sat, 26 Jan 2019 20:57:50 -0500 Subject: [PATCH 2/7] [stdevMac] refs #86 Add Python client for skycoin --- docs/BuildInfo.md | 12 + docs/DefaultApi.md | 256 ++++++++ docs/InlineResponse200.md | 10 + docs/InlineResponse422.md | 12 + docs/InlineResponseDefault.md | 11 + requirements.txt | 5 + skycoin/restapi/__init__.py | 27 + skycoin/restapi/api/__init__.py | 6 + skycoin/restapi/api/default_api.py | 488 ++++++++++++++ skycoin/restapi/api_client.py | 620 ++++++++++++++++++ skycoin/restapi/configuration.py | 246 +++++++ skycoin/restapi/models/__init__.py | 20 + skycoin/restapi/models/build_info.py | 169 +++++ skycoin/restapi/models/inline_response_200.py | 113 ++++ skycoin/restapi/models/inline_response_422.py | 163 +++++ .../restapi/models/inline_response_default.py | 137 ++++ skycoin/restapi/rest.py | 322 +++++++++ tests/restapi/__init__.py | 0 tests/restapi/test_build_info.py | 39 ++ tests/restapi/test_default_api.py | 64 ++ tests/restapi/test_inline_response_200.py | 39 ++ tests/restapi/test_inline_response_422.py | 39 ++ tests/restapi/test_inline_response_default.py | 39 ++ tox.swagger.ini | 10 + tox.ini => tox.swig.ini | 0 25 files changed, 2847 insertions(+) create mode 100644 docs/BuildInfo.md create mode 100644 docs/DefaultApi.md create mode 100644 docs/InlineResponse200.md create mode 100644 docs/InlineResponse422.md create mode 100644 docs/InlineResponseDefault.md create mode 100644 skycoin/restapi/__init__.py create mode 100644 skycoin/restapi/api/__init__.py create mode 100644 skycoin/restapi/api/default_api.py create mode 100644 skycoin/restapi/api_client.py create mode 100644 skycoin/restapi/configuration.py create mode 100644 skycoin/restapi/models/__init__.py create mode 100644 skycoin/restapi/models/build_info.py create mode 100644 skycoin/restapi/models/inline_response_200.py create mode 100644 skycoin/restapi/models/inline_response_422.py create mode 100644 skycoin/restapi/models/inline_response_default.py create mode 100644 skycoin/restapi/rest.py create mode 100644 tests/restapi/__init__.py create mode 100644 tests/restapi/test_build_info.py create mode 100644 tests/restapi/test_default_api.py create mode 100644 tests/restapi/test_inline_response_200.py create mode 100644 tests/restapi/test_inline_response_422.py create mode 100644 tests/restapi/test_inline_response_default.py create mode 100644 tox.swagger.ini rename tox.ini => tox.swig.ini (100%) diff --git a/docs/BuildInfo.md b/docs/BuildInfo.md new file mode 100644 index 00000000..cc75f1b4 --- /dev/null +++ b/docs/BuildInfo.md @@ -0,0 +1,12 @@ +# BuildInfo + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**branch** | **str** | git branch name | [optional] +**commit** | **str** | git commit id | [optional] +**version** | **str** | version number | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/DefaultApi.md b/docs/DefaultApi.md new file mode 100644 index 00000000..a7f7aef6 --- /dev/null +++ b/docs/DefaultApi.md @@ -0,0 +1,256 @@ +# swagger_client.DefaultApi + +All URIs are relative to *http://staging.node.skycoin.net* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**coin_supply**](DefaultApi.md#coin_supply) | **GET** /api/v1/coinSupply | +[**csrf_token**](DefaultApi.md#csrf_token) | **GET** /api/v1/csrf | Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. +[**resend_unconfirmed_txns**](DefaultApi.md#resend_unconfirmed_txns) | **POST** /api/v1/resendUnconfirmedTxns | +[**version**](DefaultApi.md#version) | **GET** /api/v1/version | +[**wallet_folder**](DefaultApi.md#wallet_folder) | **GET** /api/v1/wallets/folderName | + + +# **coin_supply** +> coin_supply() + + + +coinSupplyHandler returns coin distribution supply stats + +### Example +```python +from __future__ import print_function +import time +import swagger_client +from swagger_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = swagger_client.Configuration() +configuration.api_key['csrf_Token'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['csrf_Token'] = 'Bearer' + +# create an instance of the API class +api_instance = swagger_client.DefaultApi(swagger_client.ApiClient(configuration)) + +try: + api_instance.coin_supply() +except ApiException as e: + print("Exception when calling DefaultApi->coin_supply: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **csrf_token** +> InlineResponse200 csrf_token() + +Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. + +Response -> CSRF token to use in POST requests + +### Example +```python +from __future__ import print_function +import time +import swagger_client +from swagger_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = swagger_client.Configuration() +configuration.api_key['csrf_Token'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['csrf_Token'] = 'Bearer' + +# create an instance of the API class +api_instance = swagger_client.DefaultApi(swagger_client.ApiClient(configuration)) + +try: + # Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. + api_response = api_instance.csrf_token() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->csrf_token: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**InlineResponse200**](InlineResponse200.md) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **resend_unconfirmed_txns** +> resend_unconfirmed_txns() + + + +Broadcasts all unconfirmed transactions from the unconfirmed transaction pool + +### Example +```python +from __future__ import print_function +import time +import swagger_client +from swagger_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = swagger_client.Configuration() +configuration.api_key['csrf_Token'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['csrf_Token'] = 'Bearer' + +# create an instance of the API class +api_instance = swagger_client.DefaultApi(swagger_client.ApiClient(configuration)) + +try: + api_instance.resend_unconfirmed_txns() +except ApiException as e: + print("Exception when calling DefaultApi->resend_unconfirmed_txns: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **version** +> BuildInfo version() + + + +versionHandler returns the application version info + +### Example +```python +from __future__ import print_function +import time +import swagger_client +from swagger_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = swagger_client.Configuration() +configuration.api_key['csrf_Token'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['csrf_Token'] = 'Bearer' + +# create an instance of the API class +api_instance = swagger_client.DefaultApi(swagger_client.ApiClient(configuration)) + +try: + api_response = api_instance.version() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->version: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**BuildInfo**](BuildInfo.md) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_folder** +> wallet_folder() + + + +Returns the wallet directory path + +### Example +```python +from __future__ import print_function +import time +import swagger_client +from swagger_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = swagger_client.Configuration() +configuration.api_key['csrf_Token'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['csrf_Token'] = 'Bearer' + +# create an instance of the API class +api_instance = swagger_client.DefaultApi(swagger_client.ApiClient(configuration)) + +try: + api_instance.wallet_folder() +except ApiException as e: + print("Exception when calling DefaultApi->wallet_folder: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/docs/InlineResponse200.md b/docs/InlineResponse200.md new file mode 100644 index 00000000..a46f1139 --- /dev/null +++ b/docs/InlineResponse200.md @@ -0,0 +1,10 @@ +# InlineResponse200 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**csrf_token** | **str** | Csrf Token is here | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/InlineResponse422.md b/docs/InlineResponse422.md new file mode 100644 index 00000000..ec6ab28d --- /dev/null +++ b/docs/InlineResponse422.md @@ -0,0 +1,12 @@ +# InlineResponse422 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**code** | **int** | | [optional] +**field** | **str** | | [optional] +**message** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/docs/InlineResponseDefault.md b/docs/InlineResponseDefault.md new file mode 100644 index 00000000..2862e401 --- /dev/null +++ b/docs/InlineResponseDefault.md @@ -0,0 +1,11 @@ +# InlineResponseDefault + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**code** | **int** | | [optional] +**message** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/requirements.txt b/requirements.txt index b28b04f6..7f65428d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,8 @@ +certifi >= 14.05.14 +six >= 1.10 +python_dateutil >= 2.5.3 +setuptools >= 21.0.0 +urllib3 >= 1.15.1 diff --git a/skycoin/restapi/__init__.py b/skycoin/restapi/__init__.py new file mode 100644 index 00000000..3f02b925 --- /dev/null +++ b/skycoin/restapi/__init__.py @@ -0,0 +1,27 @@ +# coding: utf-8 + +# flake8: noqa + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +# import apis into sdk package +from swagger_client.api.default_api import DefaultApi + +# import ApiClient +from swagger_client.api_client import ApiClient +from swagger_client.configuration import Configuration +# import models into sdk package +from swagger_client.models.build_info import BuildInfo +from swagger_client.models.inline_response_200 import InlineResponse200 +from swagger_client.models.inline_response_422 import InlineResponse422 +from swagger_client.models.inline_response_default import InlineResponseDefault diff --git a/skycoin/restapi/api/__init__.py b/skycoin/restapi/api/__init__.py new file mode 100644 index 00000000..447bb1c3 --- /dev/null +++ b/skycoin/restapi/api/__init__.py @@ -0,0 +1,6 @@ +from __future__ import absolute_import + +# flake8: noqa + +# import apis into api package +from swagger_client.api.default_api import DefaultApi diff --git a/skycoin/restapi/api/default_api.py b/skycoin/restapi/api/default_api.py new file mode 100644 index 00000000..98cea980 --- /dev/null +++ b/skycoin/restapi/api/default_api.py @@ -0,0 +1,488 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from swagger_client.api_client import ApiClient + + +class DefaultApi(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + Ref: https://github.com/swagger-api/swagger-codegen + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def coin_supply(self, **kwargs): # noqa: E501 + """coin_supply # noqa: E501 + + coinSupplyHandler returns coin distribution supply stats # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.coin_supply(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async'): + return self.coin_supply_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.coin_supply_with_http_info(**kwargs) # noqa: E501 + return data + + def coin_supply_with_http_info(self, **kwargs): # noqa: E501 + """coin_supply # noqa: E501 + + coinSupplyHandler returns coin distribution supply stats # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.coin_supply_with_http_info(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method coin_supply" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/coinSupply', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async=params.get('async'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def csrf_token(self, **kwargs): # noqa: E501 + """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + + Response -> CSRF token to use in POST requests # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.csrf_token(async=True) + >>> result = thread.get() + + :param async bool + :return: InlineResponse200 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async'): + return self.csrf_token_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.csrf_token_with_http_info(**kwargs) # noqa: E501 + return data + + def csrf_token_with_http_info(self, **kwargs): # noqa: E501 + """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + + Response -> CSRF token to use in POST requests # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.csrf_token_with_http_info(async=True) + >>> result = thread.get() + + :param async bool + :return: InlineResponse200 + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method csrf_token" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/csrf', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse200', # noqa: E501 + auth_settings=auth_settings, + async=params.get('async'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def resend_unconfirmed_txns(self, **kwargs): # noqa: E501 + """resend_unconfirmed_txns # noqa: E501 + + Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.resend_unconfirmed_txns(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async'): + return self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 + return data + + def resend_unconfirmed_txns_with_http_info(self, **kwargs): # noqa: E501 + """resend_unconfirmed_txns # noqa: E501 + + Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.resend_unconfirmed_txns_with_http_info(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method resend_unconfirmed_txns" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/resendUnconfirmedTxns', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async=params.get('async'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def version(self, **kwargs): # noqa: E501 + """version # noqa: E501 + + versionHandler returns the application version info # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.version(async=True) + >>> result = thread.get() + + :param async bool + :return: BuildInfo + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async'): + return self.version_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.version_with_http_info(**kwargs) # noqa: E501 + return data + + def version_with_http_info(self, **kwargs): # noqa: E501 + """version # noqa: E501 + + versionHandler returns the application version info # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.version_with_http_info(async=True) + >>> result = thread.get() + + :param async bool + :return: BuildInfo + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method version" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/version', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='BuildInfo', # noqa: E501 + auth_settings=auth_settings, + async=params.get('async'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_folder(self, **kwargs): # noqa: E501 + """wallet_folder # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.wallet_folder(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async'): + return self.wallet_folder_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.wallet_folder_with_http_info(**kwargs) # noqa: E501 + return data + + def wallet_folder_with_http_info(self, **kwargs): # noqa: E501 + """wallet_folder # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async=True + >>> thread = api.wallet_folder_with_http_info(async=True) + >>> result = thread.get() + + :param async bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + all_params = [] # noqa: E501 + all_params.append('async') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + params = locals() + for key, val in six.iteritems(params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_folder" % key + ) + params[key] = val + del params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallets/folderName', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async=params.get('async'), + _return_http_data_only=params.get('_return_http_data_only'), + _preload_content=params.get('_preload_content', True), + _request_timeout=params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/skycoin/restapi/api_client.py b/skycoin/restapi/api_client.py new file mode 100644 index 00000000..fcaec015 --- /dev/null +++ b/skycoin/restapi/api_client.py @@ -0,0 +1,620 @@ +# coding: utf-8 +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + +from __future__ import absolute_import + +import datetime +import json +import mimetypes +from multiprocessing.pool import ThreadPool +import os +import re +import tempfile + +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import quote + +from swagger_client.configuration import Configuration +import swagger_client.models +from swagger_client import rest + + +class ApiClient(object): + """Generic API client for Swagger client library builds. + + Swagger generic API client. This client handles the client- + server communication, and is invariant across implementations. Specifics of + the methods and models for each application are generated from the Swagger + templates. + + NOTE: This class is auto generated by the swagger code generator program. + Ref: https://github.com/swagger-api/swagger-codegen + Do not edit the class manually. + + :param configuration: .Configuration object for this client + :param header_name: a header to pass when making calls to the API. + :param header_value: a header value to pass when making calls to + the API. + :param cookie: a cookie to include in the header when making calls + to the API + """ + + PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types + NATIVE_TYPES_MAPPING = { + 'int': int, + 'long': int if six.PY3 else long, # noqa: F821 + 'float': float, + 'str': str, + 'bool': bool, + 'date': datetime.date, + 'datetime': datetime.datetime, + 'object': object, + } + + def __init__(self, configuration=None, header_name=None, header_value=None, + cookie=None): + if configuration is None: + configuration = Configuration() + self.configuration = configuration + + self.pool = ThreadPool() + self.rest_client = rest.RESTClientObject(configuration) + self.default_headers = {} + if header_name is not None: + self.default_headers[header_name] = header_value + self.cookie = cookie + # Set default User-Agent. + self.user_agent = 'Swagger-Codegen/1.0.0/python' + + def __del__(self): + self.pool.close() + self.pool.join() + + @property + def user_agent(self): + """User agent for this API client""" + return self.default_headers['User-Agent'] + + @user_agent.setter + def user_agent(self, value): + self.default_headers['User-Agent'] = value + + def set_default_header(self, header_name, header_value): + self.default_headers[header_name] = header_value + + def __call_api( + self, resource_path, method, path_params=None, + query_params=None, header_params=None, body=None, post_params=None, + files=None, response_type=None, auth_settings=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + + config = self.configuration + + # header parameters + header_params = header_params or {} + header_params.update(self.default_headers) + if self.cookie: + header_params['Cookie'] = self.cookie + if header_params: + header_params = self.sanitize_for_serialization(header_params) + header_params = dict(self.parameters_to_tuples(header_params, + collection_formats)) + + # path parameters + if path_params: + path_params = self.sanitize_for_serialization(path_params) + path_params = self.parameters_to_tuples(path_params, + collection_formats) + for k, v in path_params: + # specified safe chars, encode everything + resource_path = resource_path.replace( + '{%s}' % k, + quote(str(v), safe=config.safe_chars_for_path_param) + ) + + # query parameters + if query_params: + query_params = self.sanitize_for_serialization(query_params) + query_params = self.parameters_to_tuples(query_params, + collection_formats) + + # post parameters + if post_params or files: + post_params = self.prepare_post_parameters(post_params, files) + post_params = self.sanitize_for_serialization(post_params) + post_params = self.parameters_to_tuples(post_params, + collection_formats) + + # auth setting + self.update_params_for_auth(header_params, query_params, auth_settings) + + # body + if body: + body = self.sanitize_for_serialization(body) + + # request url + url = self.configuration.host + resource_path + + # perform request and return response + response_data = self.request( + method, url, query_params=query_params, headers=header_params, + post_params=post_params, body=body, + _preload_content=_preload_content, + _request_timeout=_request_timeout) + + self.last_response = response_data + + return_data = response_data + if _preload_content: + # deserialize response data + if response_type: + return_data = self.deserialize(response_data, response_type) + else: + return_data = None + + if _return_http_data_only: + return (return_data) + else: + return (return_data, response_data.status, + response_data.getheaders()) + + def sanitize_for_serialization(self, obj): + """Builds a JSON POST object. + + If obj is None, return None. + If obj is str, int, long, float, bool, return directly. + If obj is datetime.datetime, datetime.date + convert to string in iso8601 format. + If obj is list, sanitize each element in the list. + If obj is dict, return the dict. + If obj is swagger model, return the properties dict. + + :param obj: The data to serialize. + :return: The serialized form of data. + """ + if obj is None: + return None + elif isinstance(obj, self.PRIMITIVE_TYPES): + return obj + elif isinstance(obj, list): + return [self.sanitize_for_serialization(sub_obj) + for sub_obj in obj] + elif isinstance(obj, tuple): + return tuple(self.sanitize_for_serialization(sub_obj) + for sub_obj in obj) + elif isinstance(obj, (datetime.datetime, datetime.date)): + return obj.isoformat() + + if isinstance(obj, dict): + obj_dict = obj + else: + # Convert model obj to dict except + # attributes `swagger_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + obj_dict = {obj.attribute_map[attr]: getattr(obj, attr) + for attr, _ in six.iteritems(obj.swagger_types) + if getattr(obj, attr) is not None} + + return {key: self.sanitize_for_serialization(val) + for key, val in six.iteritems(obj_dict)} + + def deserialize(self, response, response_type): + """Deserializes response into an object. + + :param response: RESTResponse object to be deserialized. + :param response_type: class literal for + deserialized object, or string of class name. + + :return: deserialized object. + """ + # handle file downloading + # save response body into a tmp file and return the instance + if response_type == "file": + return self.__deserialize_file(response) + + # fetch data from response object + try: + data = json.loads(response.data) + except ValueError: + data = response.data + + return self.__deserialize(data, response_type) + + def __deserialize(self, data, klass): + """Deserializes dict, list, str into an object. + + :param data: dict, list or str. + :param klass: class literal, or string of class name. + + :return: object. + """ + if data is None: + return None + + if type(klass) == str: + if klass.startswith('list['): + sub_kls = re.match('list\[(.*)\]', klass).group(1) + return [self.__deserialize(sub_data, sub_kls) + for sub_data in data] + + if klass.startswith('dict('): + sub_kls = re.match('dict\(([^,]*), (.*)\)', klass).group(2) + return {k: self.__deserialize(v, sub_kls) + for k, v in six.iteritems(data)} + + # convert str to class + if klass in self.NATIVE_TYPES_MAPPING: + klass = self.NATIVE_TYPES_MAPPING[klass] + else: + klass = getattr(swagger_client.models, klass) + + if klass in self.PRIMITIVE_TYPES: + return self.__deserialize_primitive(data, klass) + elif klass == object: + return self.__deserialize_object(data) + elif klass == datetime.date: + return self.__deserialize_date(data) + elif klass == datetime.datetime: + return self.__deserialize_datatime(data) + else: + return self.__deserialize_model(data, klass) + + def call_api(self, resource_path, method, + path_params=None, query_params=None, header_params=None, + body=None, post_params=None, files=None, + response_type=None, auth_settings=None, async=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + """Makes the HTTP request (synchronous) and returns deserialized data. + + To make an async request, set the async parameter. + + :param resource_path: Path to method endpoint. + :param method: Method to call. + :param path_params: Path parameters in the url. + :param query_params: Query parameters in the url. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param auth_settings list: Auth Settings names for the request. + :param response: Response data type. + :param files dict: key -> filename, value -> filepath, + for `multipart/form-data`. + :param async bool: execute request asynchronously + :param _return_http_data_only: response data without head status code + and headers + :param collection_formats: dict of collection formats for path, query, + header, and post parameters. + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :return: + If async parameter is True, + the request will be called asynchronously. + The method will return the request thread. + If parameter async is False or missing, + then the method will return the response directly. + """ + if not async: + return self.__call_api(resource_path, method, + path_params, query_params, header_params, + body, post_params, files, + response_type, auth_settings, + _return_http_data_only, collection_formats, + _preload_content, _request_timeout) + else: + thread = self.pool.apply_async(self.__call_api, (resource_path, + method, path_params, query_params, + header_params, body, + post_params, files, + response_type, auth_settings, + _return_http_data_only, + collection_formats, + _preload_content, _request_timeout)) + return thread + + def request(self, method, url, query_params=None, headers=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + """Makes the HTTP request using RESTClient.""" + if method == "GET": + return self.rest_client.GET(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "HEAD": + return self.rest_client.HEAD(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "OPTIONS": + return self.rest_client.OPTIONS(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "POST": + return self.rest_client.POST(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PUT": + return self.rest_client.PUT(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PATCH": + return self.rest_client.PATCH(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "DELETE": + return self.rest_client.DELETE(url, + query_params=query_params, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + else: + raise ValueError( + "http method must be `GET`, `HEAD`, `OPTIONS`," + " `POST`, `PATCH`, `PUT` or `DELETE`." + ) + + def parameters_to_tuples(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: Parameters as list of tuples, collections formatted + """ + new_params = [] + if collection_formats is None: + collection_formats = {} + for k, v in six.iteritems(params) if isinstance(params, dict) else params: # noqa: E501 + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, value) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(str(value) for value in v))) + else: + new_params.append((k, v)) + return new_params + + def prepare_post_parameters(self, post_params=None, files=None): + """Builds form parameters. + + :param post_params: Normal form parameters. + :param files: File parameters. + :return: Form parameters with files. + """ + params = [] + + if post_params: + params = post_params + + if files: + for k, v in six.iteritems(files): + if not v: + continue + file_names = v if type(v) is list else [v] + for n in file_names: + with open(n, 'rb') as f: + filename = os.path.basename(f.name) + filedata = f.read() + mimetype = (mimetypes.guess_type(filename)[0] or + 'application/octet-stream') + params.append( + tuple([k, tuple([filename, filedata, mimetype])])) + + return params + + def select_header_accept(self, accepts): + """Returns `Accept` based on an array of accepts provided. + + :param accepts: List of headers. + :return: Accept (e.g. application/json). + """ + if not accepts: + return + + accepts = [x.lower() for x in accepts] + + if 'application/json' in accepts: + return 'application/json' + else: + return ', '.join(accepts) + + def select_header_content_type(self, content_types): + """Returns `Content-Type` based on an array of content_types provided. + + :param content_types: List of content-types. + :return: Content-Type (e.g. application/json). + """ + if not content_types: + return 'application/json' + + content_types = [x.lower() for x in content_types] + + if 'application/json' in content_types or '*/*' in content_types: + return 'application/json' + else: + return content_types[0] + + def update_params_for_auth(self, headers, querys, auth_settings): + """Updates header and query params based on authentication setting. + + :param headers: Header parameters dict to be updated. + :param querys: Query parameters tuple list to be updated. + :param auth_settings: Authentication setting identifiers list. + """ + if not auth_settings: + return + + for auth in auth_settings: + auth_setting = self.configuration.auth_settings().get(auth) + if auth_setting: + if not auth_setting['value']: + continue + elif auth_setting['in'] == 'header': + headers[auth_setting['key']] = auth_setting['value'] + elif auth_setting['in'] == 'query': + querys.append((auth_setting['key'], auth_setting['value'])) + else: + raise ValueError( + 'Authentication token must be in `query` or `header`' + ) + + def __deserialize_file(self, response): + """Deserializes body to file + + Saves response body into a file in a temporary folder, + using the filename from the `Content-Disposition` header if provided. + + :param response: RESTResponse. + :return: file path. + """ + fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) + os.close(fd) + os.remove(path) + + content_disposition = response.getheader("Content-Disposition") + if content_disposition: + filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', + content_disposition).group(1) + path = os.path.join(os.path.dirname(path), filename) + + with open(path, "wb") as f: + f.write(response.data) + + return path + + def __deserialize_primitive(self, data, klass): + """Deserializes string to primitive type. + + :param data: str. + :param klass: class literal. + + :return: int, long, float, str, bool. + """ + try: + return klass(data) + except UnicodeEncodeError: + return six.u(data) + except TypeError: + return data + + def __deserialize_object(self, value): + """Return a original value. + + :return: object. + """ + return value + + def __deserialize_date(self, string): + """Deserializes string to date. + + :param string: str. + :return: date. + """ + try: + from dateutil.parser import parse + return parse(string).date() + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason="Failed to parse `{0}` as date object".format(string) + ) + + def __deserialize_datatime(self, string): + """Deserializes string to datetime. + + The string should be in iso8601 datetime format. + + :param string: str. + :return: datetime. + """ + try: + from dateutil.parser import parse + return parse(string) + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as datetime object" + .format(string) + ) + ) + + def __deserialize_model(self, data, klass): + """Deserializes list or dict to model. + + :param data: dict, list. + :param klass: class literal. + :return: model object. + """ + + if not klass.swagger_types and not hasattr(klass, + 'get_real_child_model'): + return data + + kwargs = {} + if klass.swagger_types is not None: + for attr, attr_type in six.iteritems(klass.swagger_types): + if (data is not None and + klass.attribute_map[attr] in data and + isinstance(data, (list, dict))): + value = data[klass.attribute_map[attr]] + kwargs[attr] = self.__deserialize(value, attr_type) + + instance = klass(**kwargs) + + if hasattr(instance, 'get_real_child_model'): + klass_name = instance.get_real_child_model(data) + if klass_name: + instance = self.__deserialize(data, klass_name) + return instance diff --git a/skycoin/restapi/configuration.py b/skycoin/restapi/configuration.py new file mode 100644 index 00000000..4597667f --- /dev/null +++ b/skycoin/restapi/configuration.py @@ -0,0 +1,246 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import copy +import logging +import multiprocessing +import sys +import urllib3 + +import six +from six.moves import http_client as httplib + + +class TypeWithDefault(type): + def __init__(cls, name, bases, dct): + super(TypeWithDefault, cls).__init__(name, bases, dct) + cls._default = None + + def __call__(cls): + if cls._default is None: + cls._default = type.__call__(cls) + return copy.copy(cls._default) + + def set_default(cls, default): + cls._default = copy.copy(default) + + +class Configuration(six.with_metaclass(TypeWithDefault, object)): + """NOTE: This class is auto generated by the swagger code generator program. + + Ref: https://github.com/swagger-api/swagger-codegen + Do not edit the class manually. + """ + + def __init__(self): + """Constructor""" + # Default Base url + self.host = "http://staging.node.skycoin.net" + # Temp file folder for downloading files + self.temp_folder_path = None + + # Authentication Settings + # dict to store API key(s) + self.api_key = {} + # dict to store API prefix (e.g. Bearer) + self.api_key_prefix = {} + # Username for HTTP basic authentication + self.username = "" + # Password for HTTP basic authentication + self.password = "" + + # Logging Settings + self.logger = {} + self.logger["package_logger"] = logging.getLogger("swagger_client") + self.logger["urllib3_logger"] = logging.getLogger("urllib3") + # Log format + self.logger_format = '%(asctime)s %(levelname)s %(message)s' + # Log stream handler + self.logger_stream_handler = None + # Log file handler + self.logger_file_handler = None + # Debug file location + self.logger_file = None + # Debug switch + self.debug = False + + # SSL/TLS verification + # Set this to false to skip verifying SSL certificate when calling API + # from https server. + self.verify_ssl = True + # Set this to customize the certificate file to verify the peer. + self.ssl_ca_cert = None + # client certificate file + self.cert_file = None + # client key file + self.key_file = None + # Set this to True/False to enable/disable SSL hostname verification. + self.assert_hostname = None + + # urllib3 connection pool's maximum number of connections saved + # per pool. urllib3 uses 1 connection as default value, but this is + # not the best value when you are making a lot of possibly parallel + # requests to the same host, which is often the case here. + # cpu_count * 5 is used as default value to increase performance. + self.connection_pool_maxsize = multiprocessing.cpu_count() * 5 + + # Proxy URL + self.proxy = None + # Safe chars for path_param + self.safe_chars_for_path_param = '' + + @property + def logger_file(self): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + return self.__logger_file + + @logger_file.setter + def logger_file(self, value): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + self.__logger_file = value + if self.__logger_file: + # If set logging file, + # then add file handler and remove stream handler. + self.logger_file_handler = logging.FileHandler(self.__logger_file) + self.logger_file_handler.setFormatter(self.logger_formatter) + for _, logger in six.iteritems(self.logger): + logger.addHandler(self.logger_file_handler) + if self.logger_stream_handler: + logger.removeHandler(self.logger_stream_handler) + else: + # If not set logging file, + # then add stream handler and remove file handler. + self.logger_stream_handler = logging.StreamHandler() + self.logger_stream_handler.setFormatter(self.logger_formatter) + for _, logger in six.iteritems(self.logger): + logger.addHandler(self.logger_stream_handler) + if self.logger_file_handler: + logger.removeHandler(self.logger_file_handler) + + @property + def debug(self): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + return self.__debug + + @debug.setter + def debug(self, value): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + self.__debug = value + if self.__debug: + # if debug status is True, turn on debug logging + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.DEBUG) + # turn on httplib debug + httplib.HTTPConnection.debuglevel = 1 + else: + # if debug status is False, turn off debug logging, + # setting log level to default `logging.WARNING` + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.WARNING) + # turn off httplib debug + httplib.HTTPConnection.debuglevel = 0 + + @property + def logger_format(self): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + return self.__logger_format + + @logger_format.setter + def logger_format(self, value): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + self.__logger_format = value + self.logger_formatter = logging.Formatter(self.__logger_format) + + def get_api_key_with_prefix(self, identifier): + """Gets API key (with prefix if set). + + :param identifier: The identifier of apiKey. + :return: The token for api key authentication. + """ + if (self.api_key.get(identifier) and + self.api_key_prefix.get(identifier)): + return self.api_key_prefix[identifier] + ' ' + self.api_key[identifier] # noqa: E501 + elif self.api_key.get(identifier): + return self.api_key[identifier] + + def get_basic_auth_token(self): + """Gets HTTP basic authentication header (string). + + :return: The token for basic HTTP authentication. + """ + return urllib3.util.make_headers( + basic_auth=self.username + ':' + self.password + ).get('authorization') + + def auth_settings(self): + """Gets Auth Settings dict for api client. + + :return: The Auth Settings information dict. + """ + return { + 'csrfAuth': + { + 'type': 'api_key', + 'in': 'header', + 'key': 'csrf_Token', + 'value': self.get_api_key_with_prefix('csrf_Token') + }, + + } + + def to_debug_report(self): + """Gets the essential information for debugging. + + :return: The report for debugging. + """ + return "Python SDK Debug Report:\n"\ + "OS: {env}\n"\ + "Python Version: {pyversion}\n"\ + "Version of the API: 1.0.0\n"\ + "SDK Package Version: 1.0.0".\ + format(env=sys.platform, pyversion=sys.version) diff --git a/skycoin/restapi/models/__init__.py b/skycoin/restapi/models/__init__.py new file mode 100644 index 00000000..46ba4cd9 --- /dev/null +++ b/skycoin/restapi/models/__init__.py @@ -0,0 +1,20 @@ +# coding: utf-8 + +# flake8: noqa +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +# import models into model package +from swagger_client.models.build_info import BuildInfo +from swagger_client.models.inline_response_200 import InlineResponse200 +from swagger_client.models.inline_response_422 import InlineResponse422 +from swagger_client.models.inline_response_default import InlineResponseDefault diff --git a/skycoin/restapi/models/build_info.py b/skycoin/restapi/models/build_info.py new file mode 100644 index 00000000..1bbbbf2f --- /dev/null +++ b/skycoin/restapi/models/build_info.py @@ -0,0 +1,169 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +import pprint +import re # noqa: F401 + +import six + + +class BuildInfo(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'branch': 'str', + 'commit': 'str', + 'version': 'str' + } + + attribute_map = { + 'branch': 'branch', + 'commit': 'commit', + 'version': 'version' + } + + def __init__(self, branch=None, commit=None, version=None): # noqa: E501 + """BuildInfo - a model defined in Swagger""" # noqa: E501 + + self._branch = None + self._commit = None + self._version = None + self.discriminator = None + + if branch is not None: + self.branch = branch + if commit is not None: + self.commit = commit + if version is not None: + self.version = version + + @property + def branch(self): + """Gets the branch of this BuildInfo. # noqa: E501 + + git branch name # noqa: E501 + + :return: The branch of this BuildInfo. # noqa: E501 + :rtype: str + """ + return self._branch + + @branch.setter + def branch(self, branch): + """Sets the branch of this BuildInfo. + + git branch name # noqa: E501 + + :param branch: The branch of this BuildInfo. # noqa: E501 + :type: str + """ + + self._branch = branch + + @property + def commit(self): + """Gets the commit of this BuildInfo. # noqa: E501 + + git commit id # noqa: E501 + + :return: The commit of this BuildInfo. # noqa: E501 + :rtype: str + """ + return self._commit + + @commit.setter + def commit(self, commit): + """Sets the commit of this BuildInfo. + + git commit id # noqa: E501 + + :param commit: The commit of this BuildInfo. # noqa: E501 + :type: str + """ + + self._commit = commit + + @property + def version(self): + """Gets the version of this BuildInfo. # noqa: E501 + + version number # noqa: E501 + + :return: The version of this BuildInfo. # noqa: E501 + :rtype: str + """ + return self._version + + @version.setter + def version(self, version): + """Sets the version of this BuildInfo. + + version number # noqa: E501 + + :param version: The version of this BuildInfo. # noqa: E501 + :type: str + """ + + self._version = version + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, BuildInfo): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/skycoin/restapi/models/inline_response_200.py b/skycoin/restapi/models/inline_response_200.py new file mode 100644 index 00000000..8c240a5a --- /dev/null +++ b/skycoin/restapi/models/inline_response_200.py @@ -0,0 +1,113 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse200(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'csrf_token': 'str' + } + + attribute_map = { + 'csrf_token': 'csrf_token' + } + + def __init__(self, csrf_token=None): # noqa: E501 + """InlineResponse200 - a model defined in Swagger""" # noqa: E501 + + self._csrf_token = None + self.discriminator = None + + if csrf_token is not None: + self.csrf_token = csrf_token + + @property + def csrf_token(self): + """Gets the csrf_token of this InlineResponse200. # noqa: E501 + + Csrf Token is here # noqa: E501 + + :return: The csrf_token of this InlineResponse200. # noqa: E501 + :rtype: str + """ + return self._csrf_token + + @csrf_token.setter + def csrf_token(self, csrf_token): + """Sets the csrf_token of this InlineResponse200. + + Csrf Token is here # noqa: E501 + + :param csrf_token: The csrf_token of this InlineResponse200. # noqa: E501 + :type: str + """ + + self._csrf_token = csrf_token + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse200): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/skycoin/restapi/models/inline_response_422.py b/skycoin/restapi/models/inline_response_422.py new file mode 100644 index 00000000..9c1637ef --- /dev/null +++ b/skycoin/restapi/models/inline_response_422.py @@ -0,0 +1,163 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse422(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'code': 'int', + 'field': 'str', + 'message': 'str' + } + + attribute_map = { + 'code': 'code', + 'field': 'field', + 'message': 'message' + } + + def __init__(self, code=None, field=None, message=None): # noqa: E501 + """InlineResponse422 - a model defined in Swagger""" # noqa: E501 + + self._code = None + self._field = None + self._message = None + self.discriminator = None + + if code is not None: + self.code = code + if field is not None: + self.field = field + if message is not None: + self.message = message + + @property + def code(self): + """Gets the code of this InlineResponse422. # noqa: E501 + + + :return: The code of this InlineResponse422. # noqa: E501 + :rtype: int + """ + return self._code + + @code.setter + def code(self, code): + """Sets the code of this InlineResponse422. + + + :param code: The code of this InlineResponse422. # noqa: E501 + :type: int + """ + + self._code = code + + @property + def field(self): + """Gets the field of this InlineResponse422. # noqa: E501 + + + :return: The field of this InlineResponse422. # noqa: E501 + :rtype: str + """ + return self._field + + @field.setter + def field(self, field): + """Sets the field of this InlineResponse422. + + + :param field: The field of this InlineResponse422. # noqa: E501 + :type: str + """ + + self._field = field + + @property + def message(self): + """Gets the message of this InlineResponse422. # noqa: E501 + + + :return: The message of this InlineResponse422. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this InlineResponse422. + + + :param message: The message of this InlineResponse422. # noqa: E501 + :type: str + """ + + self._message = message + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse422): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/skycoin/restapi/models/inline_response_default.py b/skycoin/restapi/models/inline_response_default.py new file mode 100644 index 00000000..10e94157 --- /dev/null +++ b/skycoin/restapi/models/inline_response_default.py @@ -0,0 +1,137 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponseDefault(object): + """NOTE: This class is auto generated by the swagger code generator program. + + Do not edit the class manually. + """ + + """ + Attributes: + swagger_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + swagger_types = { + 'code': 'int', + 'message': 'str' + } + + attribute_map = { + 'code': 'code', + 'message': 'message' + } + + def __init__(self, code=None, message=None): # noqa: E501 + """InlineResponseDefault - a model defined in Swagger""" # noqa: E501 + + self._code = None + self._message = None + self.discriminator = None + + if code is not None: + self.code = code + if message is not None: + self.message = message + + @property + def code(self): + """Gets the code of this InlineResponseDefault. # noqa: E501 + + + :return: The code of this InlineResponseDefault. # noqa: E501 + :rtype: int + """ + return self._code + + @code.setter + def code(self, code): + """Sets the code of this InlineResponseDefault. + + + :param code: The code of this InlineResponseDefault. # noqa: E501 + :type: int + """ + + self._code = code + + @property + def message(self): + """Gets the message of this InlineResponseDefault. # noqa: E501 + + + :return: The message of this InlineResponseDefault. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this InlineResponseDefault. + + + :param message: The message of this InlineResponseDefault. # noqa: E501 + :type: str + """ + + self._message = message + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.swagger_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponseDefault): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/skycoin/restapi/rest.py b/skycoin/restapi/rest.py new file mode 100644 index 00000000..ed2892c0 --- /dev/null +++ b/skycoin/restapi/rest.py @@ -0,0 +1,322 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import io +import json +import logging +import re +import ssl + +import certifi +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import urlencode + +try: + import urllib3 +except ImportError: + raise ImportError('Swagger python client requires urllib3.') + + +logger = logging.getLogger(__name__) + + +class RESTResponse(io.IOBase): + + def __init__(self, resp): + self.urllib3_response = resp + self.status = resp.status + self.reason = resp.reason + self.data = resp.data + + def getheaders(self): + """Returns a dictionary of the response headers.""" + return self.urllib3_response.getheaders() + + def getheader(self, name, default=None): + """Returns a given response header.""" + return self.urllib3_response.getheader(name, default) + + +class RESTClientObject(object): + + def __init__(self, configuration, pools_size=4, maxsize=None): + # urllib3.PoolManager will pass all kw parameters to connectionpool + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 + # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 + # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 + + # cert_reqs + if configuration.verify_ssl: + cert_reqs = ssl.CERT_REQUIRED + else: + cert_reqs = ssl.CERT_NONE + + # ca_certs + if configuration.ssl_ca_cert: + ca_certs = configuration.ssl_ca_cert + else: + # if not set certificate file, use Mozilla's root certificates. + ca_certs = certifi.where() + + addition_pool_args = {} + if configuration.assert_hostname is not None: + addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 + + if maxsize is None: + if configuration.connection_pool_maxsize is not None: + maxsize = configuration.connection_pool_maxsize + else: + maxsize = 4 + + # https pool manager + if configuration.proxy: + self.pool_manager = urllib3.ProxyManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + proxy_url=configuration.proxy, + **addition_pool_args + ) + else: + self.pool_manager = urllib3.PoolManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + **addition_pool_args + ) + + def request(self, method, url, query_params=None, headers=None, + body=None, post_params=None, _preload_content=True, + _request_timeout=None): + """Perform requests. + + :param method: http request method + :param url: http request url + :param query_params: query parameters in the url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + """ + method = method.upper() + assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', + 'PATCH', 'OPTIONS'] + + if post_params and body: + raise ValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + + timeout = None + if _request_timeout: + if isinstance(_request_timeout, (int, ) if six.PY3 else (int, long)): # noqa: E501,F821 + timeout = urllib3.Timeout(total=_request_timeout) + elif (isinstance(_request_timeout, tuple) and + len(_request_timeout) == 2): + timeout = urllib3.Timeout( + connect=_request_timeout[0], read=_request_timeout[1]) + + if 'Content-Type' not in headers: + headers['Content-Type'] = 'application/json' + + try: + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + if query_params: + url += '?' + urlencode(query_params) + if re.search('json', headers['Content-Type'], re.IGNORECASE): + request_body = None + if body is not None: + request_body = json.dumps(body) + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=False, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by urllib3 will be + # overwritten. + del headers['Content-Type'] + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=True, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + # Pass a `string` parameter directly in the body to support + # other content types than Json when `body` argument is + # provided in serialized form + elif isinstance(body, str): + request_body = body + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + # For `GET`, `HEAD` + else: + r = self.pool_manager.request(method, url, + fields=query_params, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + except urllib3.exceptions.SSLError as e: + msg = "{0}\n{1}".format(type(e).__name__, str(e)) + raise ApiException(status=0, reason=msg) + + if _preload_content: + r = RESTResponse(r) + + # In the python 3, the response.data is bytes. + # we need to decode it to string. + if six.PY3: + r.data = r.data.decode('utf8') + + # log response body + logger.debug("response body: %s", r.data) + + if not 200 <= r.status <= 299: + raise ApiException(http_resp=r) + + return r + + def GET(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("GET", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def HEAD(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("HEAD", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def OPTIONS(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("OPTIONS", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def DELETE(self, url, headers=None, query_params=None, body=None, + _preload_content=True, _request_timeout=None): + return self.request("DELETE", url, + headers=headers, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def POST(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("POST", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PUT(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PUT", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PATCH(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PATCH", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + +class ApiException(Exception): + + def __init__(self, status=None, reason=None, http_resp=None): + if http_resp: + self.status = http_resp.status + self.reason = http_resp.reason + self.body = http_resp.data + self.headers = http_resp.getheaders() + else: + self.status = status + self.reason = reason + self.body = None + self.headers = None + + def __str__(self): + """Custom error messages for exception""" + error_message = "({0})\n"\ + "Reason: {1}\n".format(self.status, self.reason) + if self.headers: + error_message += "HTTP response headers: {0}\n".format( + self.headers) + + if self.body: + error_message += "HTTP response body: {0}\n".format(self.body) + + return error_message diff --git a/tests/restapi/__init__.py b/tests/restapi/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/restapi/test_build_info.py b/tests/restapi/test_build_info.py new file mode 100644 index 00000000..a53da0ca --- /dev/null +++ b/tests/restapi/test_build_info.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import swagger_client +from swagger_client.models.build_info import BuildInfo # noqa: E501 +from swagger_client.rest import ApiException + + +class TestBuildInfo(unittest.TestCase): + """BuildInfo unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testBuildInfo(self): + """Test BuildInfo""" + # FIXME: construct object with mandatory attributes with example values + # model = swagger_client.models.build_info.BuildInfo() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/restapi/test_default_api.py b/tests/restapi/test_default_api.py new file mode 100644 index 00000000..81cfd033 --- /dev/null +++ b/tests/restapi/test_default_api.py @@ -0,0 +1,64 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import swagger_client +from swagger_client.api.default_api import DefaultApi # noqa: E501 +from swagger_client.rest import ApiException + + +class TestDefaultApi(unittest.TestCase): + """DefaultApi unit test stubs""" + + def setUp(self): + self.api = swagger_client.api.default_api.DefaultApi() # noqa: E501 + + def tearDown(self): + pass + + def test_coin_supply(self): + """Test case for coin_supply + + """ + pass + + def test_csrf_token(self): + """Test case for csrf_token + + Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + """ + pass + + def test_resend_unconfirmed_txns(self): + """Test case for resend_unconfirmed_txns + + """ + pass + + def test_version(self): + """Test case for version + + """ + pass + + def test_wallet_folder(self): + """Test case for wallet_folder + + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/restapi/test_inline_response_200.py b/tests/restapi/test_inline_response_200.py new file mode 100644 index 00000000..2ace8516 --- /dev/null +++ b/tests/restapi/test_inline_response_200.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import swagger_client +from swagger_client.models.inline_response_200 import InlineResponse200 # noqa: E501 +from swagger_client.rest import ApiException + + +class TestInlineResponse200(unittest.TestCase): + """InlineResponse200 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse200(self): + """Test InlineResponse200""" + # FIXME: construct object with mandatory attributes with example values + # model = swagger_client.models.inline_response_200.InlineResponse200() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/restapi/test_inline_response_422.py b/tests/restapi/test_inline_response_422.py new file mode 100644 index 00000000..8399fb5e --- /dev/null +++ b/tests/restapi/test_inline_response_422.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import swagger_client +from swagger_client.models.inline_response_422 import InlineResponse422 # noqa: E501 +from swagger_client.rest import ApiException + + +class TestInlineResponse422(unittest.TestCase): + """InlineResponse422 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse422(self): + """Test InlineResponse422""" + # FIXME: construct object with mandatory attributes with example values + # model = swagger_client.models.inline_response_422.InlineResponse422() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/restapi/test_inline_response_default.py b/tests/restapi/test_inline_response_default.py new file mode 100644 index 00000000..df1d7ff5 --- /dev/null +++ b/tests/restapi/test_inline_response_default.py @@ -0,0 +1,39 @@ +# coding: utf-8 + +""" + + No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + + OpenAPI spec version: 1.0.0 + Contact: contact@skycoin.net + Generated by: https://github.com/swagger-api/swagger-codegen.git +""" + + +from __future__ import absolute_import + +import unittest + +import swagger_client +from swagger_client.models.inline_response_default import InlineResponseDefault # noqa: E501 +from swagger_client.rest import ApiException + + +class TestInlineResponseDefault(unittest.TestCase): + """InlineResponseDefault unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponseDefault(self): + """Test InlineResponseDefault""" + # FIXME: construct object with mandatory attributes with example values + # model = swagger_client.models.inline_response_default.InlineResponseDefault() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tox.swagger.ini b/tox.swagger.ini new file mode 100644 index 00000000..1cf0829d --- /dev/null +++ b/tox.swagger.ini @@ -0,0 +1,10 @@ +[tox] +envlist = py27, py3 + +[testenv] +deps=-r{toxinidir}/requirements.txt + -r{toxinidir}/test-requirements.txt + +commands= + nosetests \ + [] \ No newline at end of file diff --git a/tox.ini b/tox.swig.ini similarity index 100% rename from tox.ini rename to tox.swig.ini From 5e95d020af6c5caec3dce848c7d6bbdb7d4aacc3 Mon Sep 17 00:00:00 2001 From: Marcos Maceo Date: Wed, 6 Mar 2019 09:39:27 -0500 Subject: [PATCH 3/7] [stdevMac] refs #86 Update Makefile --- Makefile | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/Makefile b/Makefile index 4e187086..3b46337c 100644 --- a/Makefile +++ b/Makefile @@ -25,6 +25,9 @@ SRC_FILES = $(shell find $(SKYCOIN_DIR)/src -type f -name "*.go") SWIG_FILES = $(shell find $(LIBSWIG_DIR) -type f -name "*.i") HEADER_FILES = $(shell find $(SKYCOIN_DIR)/include -type f -name "*.h") +SWAGGER_SPEC_DIR = get in some way swagger spec route +PYTHON_CLIENT_DIR = url python client + ifeq ($(shell uname -s),Linux) TEMP_DIR = tmp else ifeq ($(shell uname -s),Darwin) @@ -35,6 +38,15 @@ configure: ## Configure build environment mkdir -p $(BUILD_DIR)/usr/tmp $(BUILD_DIR)/usr/lib $(BUILD_DIR)/usr/include mkdir -p $(BUILDLIBC_DIR) $(BIN_DIR) $(INCLUDE_DIR) mkdir -p $(DIST_DIR) +generate-swagger: + GOPATH="$(GOPATH_DIR)" make -C $(LIB_SKYCOIN_DIR) swagger2 + rm -rf CSHARP_CLIENT_DIR + @openapi-generator generate -g py --additional-properties=prependFormOrBodyParameters=true -o $(PYTHON_CLIENT_DIR)/python-swagger-client -i $(SWAGGER_SPEC_DIR)/skycoin.openapi.v2.yml + +generate-python-Client: ## Configure build environment + mkdir -p $(BUILD_DIR)/usr/tmp $(BUILD_DIR)/usr/lib $(BUILD_DIR)/usr/include + mkdir -p $(BUILDLIBC_DIR) $(BIN_DIR) $(INCLUDE_DIR) + mkdir -p $(DIST_DIR) $(BUILDLIBC_DIR)/libskycoin.a: $(LIB_FILES) $(SRC_FILES) $(HEADER_FILES) rm -f $(BUILDLIBC_DIR)/libskycoin.a From e294b8640f121f5081e6215c5f9279bee5176a4e Mon Sep 17 00:00:00 2001 From: Marcos Maceo Date: Sat, 9 Mar 2019 23:24:04 -0500 Subject: [PATCH 4/7] [stdevMac] refs #86 Added Python wrapper for skycoin api v0.25.1 --- Makefile | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Makefile b/Makefile index 3b46337c..8aa44b86 100644 --- a/Makefile +++ b/Makefile @@ -38,10 +38,6 @@ configure: ## Configure build environment mkdir -p $(BUILD_DIR)/usr/tmp $(BUILD_DIR)/usr/lib $(BUILD_DIR)/usr/include mkdir -p $(BUILDLIBC_DIR) $(BIN_DIR) $(INCLUDE_DIR) mkdir -p $(DIST_DIR) -generate-swagger: - GOPATH="$(GOPATH_DIR)" make -C $(LIB_SKYCOIN_DIR) swagger2 - rm -rf CSHARP_CLIENT_DIR - @openapi-generator generate -g py --additional-properties=prependFormOrBodyParameters=true -o $(PYTHON_CLIENT_DIR)/python-swagger-client -i $(SWAGGER_SPEC_DIR)/skycoin.openapi.v2.yml generate-python-Client: ## Configure build environment mkdir -p $(BUILD_DIR)/usr/tmp $(BUILD_DIR)/usr/lib $(BUILD_DIR)/usr/include From 7b3e0227e74a2caf7bdccbcf91f0ace33e6ccd33 Mon Sep 17 00:00:00 2001 From: Marcos Maceo Date: Tue, 12 Mar 2019 17:44:14 -0400 Subject: [PATCH 5/7] [pyrest] refs #86 Set tox test --- pysky_api/.gitignore | 64 + pysky_api/.openapi-generator-ignore | 23 + pysky_api/.openapi-generator/VERSION | 1 + pysky_api/.travis.yml | 14 + pysky_api/README.md | 165 + pysky_api/docs/Apiv1exploreraddressInputs.md | 14 + pysky_api/docs/Apiv1exploreraddressOutputs.md | 13 + pysky_api/docs/Apiv1exploreraddressStatus.md | 13 + pysky_api/docs/Apiv1pendingTxsTransaction.md | 17 + pysky_api/docs/Apiv1walletsEntries.md | 11 + pysky_api/docs/Apiv1walletsMeta.md | 17 + .../Apiv1wallettransactionHoursSelection.md | 12 + pysky_api/docs/Apiv1wallettransactionTo.md | 12 + .../docs/Apiv1wallettransactionWallet.md | 13 + pysky_api/docs/DefaultApi.md | 2597 +++ pysky_api/docs/InlineObject.md | 14 + pysky_api/docs/InlineResponse200.md | 18 + pysky_api/docs/InlineResponse2001.md | 10 + pysky_api/docs/InlineResponse2002.md | 19 + pysky_api/docs/InlineResponse2003.md | 22 + ...esponse2003UnconfirmedVerifyTransaction.md | 12 + pysky_api/docs/InlineResponse2004.md | 14 + pysky_api/docs/InlineResponse2005.md | 11 + pysky_api/docs/InlineResponse2006.md | 10 + pysky_api/docs/InlineResponse2007.md | 11 + pysky_api/docs/InlineResponse2007Data.md | 10 + pysky_api/docs/InlineResponseDefault.md | 11 + pysky_api/git_push.sh | 52 + pysky_api/openapi_client/__init__.py | 47 + pysky_api/openapi_client/api/__init__.py | 6 + pysky_api/openapi_client/api/default_api.py | 4854 +++++ pysky_api/openapi_client/api_client.py | 635 + pysky_api/openapi_client/configuration.py | 236 + pysky_api/openapi_client/models/__init__.py | 38 + .../models/apiv1exploreraddress_inputs.py | 217 + .../models/apiv1exploreraddress_outputs.py | 191 + .../models/apiv1exploreraddress_status.py | 191 + .../models/apiv1pending_txs_transaction.py | 295 + .../models/apiv1wallets_entries.py | 139 + .../models/apiv1wallets_meta.py | 295 + .../apiv1wallettransaction_hours_selection.py | 165 + .../models/apiv1wallettransaction_to.py | 165 + .../models/apiv1wallettransaction_wallet.py | 191 + .../openapi_client/models/inline_object.py | 217 + .../models/inline_response200.py | 321 + .../models/inline_response2001.py | 113 + .../models/inline_response2002.py | 347 + .../models/inline_response2003.py | 431 + ...onse2003_unconfirmed_verify_transaction.py | 165 + .../models/inline_response2004.py | 217 + .../models/inline_response2005.py | 139 + .../models/inline_response2006.py | 113 + .../models/inline_response2007.py | 139 + .../models/inline_response2007_data.py | 113 + .../models/inline_response_default.py | 139 + pysky_api/openapi_client/rest.py | 323 + pysky_api/requirements.txt | 5 + pysky_api/setup.py | 40 + pysky_api/test-requirements.txt | 5 + {tests/restapi => pysky_api/test}/__init__.py | 0 .../test/test_apiv1exploreraddress_inputs.py | 40 + .../test/test_apiv1exploreraddress_outputs.py | 40 + .../test/test_apiv1exploreraddress_status.py | 40 + .../test/test_apiv1pending_txs_transaction.py | 40 + pysky_api/test/test_apiv1wallets_entries.py | 40 + pysky_api/test/test_apiv1wallets_meta.py | 40 + ..._apiv1wallettransaction_hours_selection.py | 40 + .../test/test_apiv1wallettransaction_to.py | 40 + .../test_apiv1wallettransaction_wallet.py | 40 + pysky_api/test/test_default_api.py | 371 + pysky_api/test/test_inline_object.py | 40 + pysky_api/test/test_inline_response200.py | 40 + pysky_api/test/test_inline_response2001.py | 40 + pysky_api/test/test_inline_response2002.py | 40 + pysky_api/test/test_inline_response2003.py | 40 + ...onse2003_unconfirmed_verify_transaction.py | 40 + pysky_api/test/test_inline_response2004.py | 40 + pysky_api/test/test_inline_response2005.py | 40 + pysky_api/test/test_inline_response2006.py | 40 + pysky_api/test/test_inline_response2007.py | 40 + .../test/test_inline_response2007_data.py | 40 + .../test}/test_inline_response_default.py | 17 +- tox.swagger.ini => pysky_api/tox.ini | 4 +- skycoin/skycoin.py | 2080 +- swig/pyskycoin_wrap.c | 16148 ++++++++-------- tests/restapi/test_build_info.py | 39 - tests/restapi/test_default_api.py | 64 - tests/restapi/test_inline_response_200.py | 39 - tests/restapi/test_inline_response_422.py | 39 - 89 files changed, 23988 insertions(+), 9305 deletions(-) create mode 100644 pysky_api/.gitignore create mode 100644 pysky_api/.openapi-generator-ignore create mode 100644 pysky_api/.openapi-generator/VERSION create mode 100644 pysky_api/.travis.yml create mode 100644 pysky_api/README.md create mode 100644 pysky_api/docs/Apiv1exploreraddressInputs.md create mode 100644 pysky_api/docs/Apiv1exploreraddressOutputs.md create mode 100644 pysky_api/docs/Apiv1exploreraddressStatus.md create mode 100644 pysky_api/docs/Apiv1pendingTxsTransaction.md create mode 100644 pysky_api/docs/Apiv1walletsEntries.md create mode 100644 pysky_api/docs/Apiv1walletsMeta.md create mode 100644 pysky_api/docs/Apiv1wallettransactionHoursSelection.md create mode 100644 pysky_api/docs/Apiv1wallettransactionTo.md create mode 100644 pysky_api/docs/Apiv1wallettransactionWallet.md create mode 100644 pysky_api/docs/DefaultApi.md create mode 100644 pysky_api/docs/InlineObject.md create mode 100644 pysky_api/docs/InlineResponse200.md create mode 100644 pysky_api/docs/InlineResponse2001.md create mode 100644 pysky_api/docs/InlineResponse2002.md create mode 100644 pysky_api/docs/InlineResponse2003.md create mode 100644 pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md create mode 100644 pysky_api/docs/InlineResponse2004.md create mode 100644 pysky_api/docs/InlineResponse2005.md create mode 100644 pysky_api/docs/InlineResponse2006.md create mode 100644 pysky_api/docs/InlineResponse2007.md create mode 100644 pysky_api/docs/InlineResponse2007Data.md create mode 100644 pysky_api/docs/InlineResponseDefault.md create mode 100644 pysky_api/git_push.sh create mode 100644 pysky_api/openapi_client/__init__.py create mode 100644 pysky_api/openapi_client/api/__init__.py create mode 100644 pysky_api/openapi_client/api/default_api.py create mode 100644 pysky_api/openapi_client/api_client.py create mode 100644 pysky_api/openapi_client/configuration.py create mode 100644 pysky_api/openapi_client/models/__init__.py create mode 100644 pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py create mode 100644 pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py create mode 100644 pysky_api/openapi_client/models/apiv1exploreraddress_status.py create mode 100644 pysky_api/openapi_client/models/apiv1pending_txs_transaction.py create mode 100644 pysky_api/openapi_client/models/apiv1wallets_entries.py create mode 100644 pysky_api/openapi_client/models/apiv1wallets_meta.py create mode 100644 pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py create mode 100644 pysky_api/openapi_client/models/apiv1wallettransaction_to.py create mode 100644 pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py create mode 100644 pysky_api/openapi_client/models/inline_object.py create mode 100644 pysky_api/openapi_client/models/inline_response200.py create mode 100644 pysky_api/openapi_client/models/inline_response2001.py create mode 100644 pysky_api/openapi_client/models/inline_response2002.py create mode 100644 pysky_api/openapi_client/models/inline_response2003.py create mode 100644 pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py create mode 100644 pysky_api/openapi_client/models/inline_response2004.py create mode 100644 pysky_api/openapi_client/models/inline_response2005.py create mode 100644 pysky_api/openapi_client/models/inline_response2006.py create mode 100644 pysky_api/openapi_client/models/inline_response2007.py create mode 100644 pysky_api/openapi_client/models/inline_response2007_data.py create mode 100644 pysky_api/openapi_client/models/inline_response_default.py create mode 100644 pysky_api/openapi_client/rest.py create mode 100644 pysky_api/requirements.txt create mode 100644 pysky_api/setup.py create mode 100644 pysky_api/test-requirements.txt rename {tests/restapi => pysky_api/test}/__init__.py (100%) create mode 100644 pysky_api/test/test_apiv1exploreraddress_inputs.py create mode 100644 pysky_api/test/test_apiv1exploreraddress_outputs.py create mode 100644 pysky_api/test/test_apiv1exploreraddress_status.py create mode 100644 pysky_api/test/test_apiv1pending_txs_transaction.py create mode 100644 pysky_api/test/test_apiv1wallets_entries.py create mode 100644 pysky_api/test/test_apiv1wallets_meta.py create mode 100644 pysky_api/test/test_apiv1wallettransaction_hours_selection.py create mode 100644 pysky_api/test/test_apiv1wallettransaction_to.py create mode 100644 pysky_api/test/test_apiv1wallettransaction_wallet.py create mode 100644 pysky_api/test/test_default_api.py create mode 100644 pysky_api/test/test_inline_object.py create mode 100644 pysky_api/test/test_inline_response200.py create mode 100644 pysky_api/test/test_inline_response2001.py create mode 100644 pysky_api/test/test_inline_response2002.py create mode 100644 pysky_api/test/test_inline_response2003.py create mode 100644 pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py create mode 100644 pysky_api/test/test_inline_response2004.py create mode 100644 pysky_api/test/test_inline_response2005.py create mode 100644 pysky_api/test/test_inline_response2006.py create mode 100644 pysky_api/test/test_inline_response2007.py create mode 100644 pysky_api/test/test_inline_response2007_data.py rename {tests/restapi => pysky_api/test}/test_inline_response_default.py (55%) rename tox.swagger.ini => pysky_api/tox.ini (89%) delete mode 100644 tests/restapi/test_build_info.py delete mode 100644 tests/restapi/test_default_api.py delete mode 100644 tests/restapi/test_inline_response_200.py delete mode 100644 tests/restapi/test_inline_response_422.py diff --git a/pysky_api/.gitignore b/pysky_api/.gitignore new file mode 100644 index 00000000..a655050c --- /dev/null +++ b/pysky_api/.gitignore @@ -0,0 +1,64 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +env/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*,cover +.hypothesis/ +venv/ +.python-version + +# Translations +*.mo +*.pot + +# Django stuff: +*.log + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +#Ipython Notebook +.ipynb_checkpoints diff --git a/pysky_api/.openapi-generator-ignore b/pysky_api/.openapi-generator-ignore new file mode 100644 index 00000000..7484ee59 --- /dev/null +++ b/pysky_api/.openapi-generator-ignore @@ -0,0 +1,23 @@ +# OpenAPI Generator Ignore +# Generated by openapi-generator https://github.com/openapitools/openapi-generator + +# Use this file to prevent files from being overwritten by the generator. +# The patterns follow closely to .gitignore or .dockerignore. + +# As an example, the C# client generator defines ApiClient.cs. +# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line: +#ApiClient.cs + +# You can match any string of characters against a directory, file or extension with a single asterisk (*): +#foo/*/qux +# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux + +# You can recursively match patterns against a directory, file or extension with a double asterisk (**): +#foo/**/qux +# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux + +# You can also negate patterns with an exclamation (!). +# For example, you can ignore all files in a docs folder with the file extension .md: +#docs/*.md +# Then explicitly reverse the ignore rule for a single file: +#!docs/README.md diff --git a/pysky_api/.openapi-generator/VERSION b/pysky_api/.openapi-generator/VERSION new file mode 100644 index 00000000..2c6109e5 --- /dev/null +++ b/pysky_api/.openapi-generator/VERSION @@ -0,0 +1 @@ +3.3.4 \ No newline at end of file diff --git a/pysky_api/.travis.yml b/pysky_api/.travis.yml new file mode 100644 index 00000000..86211e2d --- /dev/null +++ b/pysky_api/.travis.yml @@ -0,0 +1,14 @@ +# ref: https://docs.travis-ci.com/user/languages/python +language: python +python: + - "2.7" + - "3.2" + - "3.3" + - "3.4" + - "3.5" + #- "3.5-dev" # 3.5 development branch + #- "nightly" # points to the latest development branch e.g. 3.6-dev +# command to install dependencies +install: "pip install -r requirements.txt" +# command to run tests +script: nosetests diff --git a/pysky_api/README.md b/pysky_api/README.md new file mode 100644 index 00000000..c16cd70b --- /dev/null +++ b/pysky_api/README.md @@ -0,0 +1,165 @@ +# openapi-client +Skycoin is a next-generation cryptocurrency. + +This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project: + +- API version: 0.25.1 +- Package version: 1.0.0 +- Build package: org.openapitools.codegen.languages.PythonClientCodegen +For more information, please visit [http://127.0.0.1:6420](http://127.0.0.1:6420) + +## Requirements. + +Python 2.7 and 3.4+ + +## Installation & Usage +### pip install + +If the python package is hosted on Github, you can install directly from Github + +```sh +pip install git+https://github.com/GIT_USER_ID/GIT_REPO_ID.git +``` +(you may need to run `pip` with root permission: `sudo pip install git+https://github.com/GIT_USER_ID/GIT_REPO_ID.git`) + +Then import the package: +```python +import openapi_client +``` + +### Setuptools + +Install via [Setuptools](http://pypi.python.org/pypi/setuptools). + +```sh +python setup.py install --user +``` +(or `sudo python setup.py install` to install the package for all users) + +Then import the package: +```python +import openapi_client +``` + +## Getting Started + +Please follow the [installation procedure](#installation--usage) and then run the following: + +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) + +try: + # Returns the total number of unique address that have coins. + api_response = api_instance.address_count() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->address_count: %s\n" % e) + +``` + +## Documentation for API Endpoints + +All URIs are relative to *http://127.0.0.1:6420* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*DefaultApi* | [**address_count**](docs/DefaultApi.md#address_count) | **GET** /api/v1/addresscount | Returns the total number of unique address that have coins. +*DefaultApi* | [**address_uxouts**](docs/DefaultApi.md#address_uxouts) | **GET** /api/v1/address_uxouts | +*DefaultApi* | [**balance_get**](docs/DefaultApi.md#balance_get) | **GET** /api/v1/balance | Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +*DefaultApi* | [**balance_post**](docs/DefaultApi.md#balance_post) | **POST** /api/v1/balance | Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +*DefaultApi* | [**block**](docs/DefaultApi.md#block) | **GET** /api/v1/block | +*DefaultApi* | [**blockchain_metadata**](docs/DefaultApi.md#blockchain_metadata) | **GET** /api/v1/blockchain/metadata | Returns the blockchain metadata. +*DefaultApi* | [**blockchain_progress**](docs/DefaultApi.md#blockchain_progress) | **GET** /api/v1/blockchain/progress | Returns the blockchain sync progress. +*DefaultApi* | [**blocks_get**](docs/DefaultApi.md#blocks_get) | **GET** /api/v1/blocks | blocksHandler returns blocks between a start and end point, +*DefaultApi* | [**blocks_post**](docs/DefaultApi.md#blocks_post) | **POST** /api/v1/blocks | blocksHandler returns blocks between a start and end point, +*DefaultApi* | [**coin_supply**](docs/DefaultApi.md#coin_supply) | **GET** /api/v1/coinSupply | +*DefaultApi* | [**csrf**](docs/DefaultApi.md#csrf) | **GET** /api/v1/csrf | Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. +*DefaultApi* | [**default_connections**](docs/DefaultApi.md#default_connections) | **GET** /api/v1/network/defaultConnections | defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. +*DefaultApi* | [**explorer_address**](docs/DefaultApi.md#explorer_address) | **GET** /api/v1/explorer/address | +*DefaultApi* | [**health**](docs/DefaultApi.md#health) | **GET** /api/v1/health | Returns node health data. +*DefaultApi* | [**last_blocks**](docs/DefaultApi.md#last_blocks) | **GET** /api/v1/last_blocks | +*DefaultApi* | [**network_connection**](docs/DefaultApi.md#network_connection) | **GET** /api/v1/network/connection | This endpoint returns a specific connection. +*DefaultApi* | [**network_connections**](docs/DefaultApi.md#network_connections) | **GET** /api/v1/network/connections | This endpoint returns all outgoings connections. +*DefaultApi* | [**network_connections_disconnect**](docs/DefaultApi.md#network_connections_disconnect) | **POST** /api/v1/network/connection/disconnect | +*DefaultApi* | [**network_connections_exchange**](docs/DefaultApi.md#network_connections_exchange) | **GET** /api/v1/network/connections/exchange | +*DefaultApi* | [**network_connections_trust**](docs/DefaultApi.md#network_connections_trust) | **GET** /api/v1/network/connections/trust | trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. +*DefaultApi* | [**outputs_get**](docs/DefaultApi.md#outputs_get) | **GET** /api/v1/outputs | If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. +*DefaultApi* | [**outputs_post**](docs/DefaultApi.md#outputs_post) | **POST** /api/v1/outputs | If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. +*DefaultApi* | [**pending_txs**](docs/DefaultApi.md#pending_txs) | **GET** /api/v1/pendingTxs | +*DefaultApi* | [**resend_unconfirmed_txns**](docs/DefaultApi.md#resend_unconfirmed_txns) | **POST** /api/v1/resendUnconfirmedTxns | +*DefaultApi* | [**richlist**](docs/DefaultApi.md#richlist) | **GET** /api/v1/richlist | Returns the top skycoin holders. +*DefaultApi* | [**transaction**](docs/DefaultApi.md#transaction) | **GET** /api/v1/transaction | +*DefaultApi* | [**transaction_inject**](docs/DefaultApi.md#transaction_inject) | **POST** /api/v2/transaction/inject | Broadcast a hex-encoded, serialized transaction to the network. +*DefaultApi* | [**transaction_raw**](docs/DefaultApi.md#transaction_raw) | **GET** /api/v2/transaction/raw | Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. +*DefaultApi* | [**transaction_verify**](docs/DefaultApi.md#transaction_verify) | **POST** /api/v2/transaction/verify | +*DefaultApi* | [**transactions_get**](docs/DefaultApi.md#transactions_get) | **GET** /api/v1/transactions | Returns transactions that match the filters. +*DefaultApi* | [**transactions_post**](docs/DefaultApi.md#transactions_post) | **POST** /api/v1/transactions | Returns transactions that match the filters. +*DefaultApi* | [**uxout**](docs/DefaultApi.md#uxout) | **GET** /api/v1/uxout | Returns an unspent output by ID. +*DefaultApi* | [**verify_address**](docs/DefaultApi.md#verify_address) | **POST** /api/v2/address/verify | Verifies a Skycoin address. +*DefaultApi* | [**version**](docs/DefaultApi.md#version) | **GET** /api/v1/version | +*DefaultApi* | [**wallet**](docs/DefaultApi.md#wallet) | **GET** /api/v1/wallet | Returns a wallet by id. +*DefaultApi* | [**wallet_balance**](docs/DefaultApi.md#wallet_balance) | **GET** /api/v1/wallet/balance | Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +*DefaultApi* | [**wallet_create**](docs/DefaultApi.md#wallet_create) | **POST** /api/v1/wallet/create | +*DefaultApi* | [**wallet_decrypt**](docs/DefaultApi.md#wallet_decrypt) | **POST** /api/v1/wallet/decrypt | Decrypts wallet. +*DefaultApi* | [**wallet_encrypt**](docs/DefaultApi.md#wallet_encrypt) | **POST** /api/v1/wallet/encrypt | Encrypt wallet. +*DefaultApi* | [**wallet_folder**](docs/DefaultApi.md#wallet_folder) | **GET** /api/v1/wallets/folderName | +*DefaultApi* | [**wallet_new_address**](docs/DefaultApi.md#wallet_new_address) | **POST** /api/v1/wallet/newAddress | +*DefaultApi* | [**wallet_new_seed**](docs/DefaultApi.md#wallet_new_seed) | **GET** /api/v1/wallet/newSeed | +*DefaultApi* | [**wallet_recover**](docs/DefaultApi.md#wallet_recover) | **POST** /api/v2/wallet/recover | Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. +*DefaultApi* | [**wallet_seed**](docs/DefaultApi.md#wallet_seed) | **POST** /api/v1/wallet/seed | This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. +*DefaultApi* | [**wallet_seed_verify**](docs/DefaultApi.md#wallet_seed_verify) | **POST** /api/v2/wallet/seed/verify | Verifies a wallet seed. +*DefaultApi* | [**wallet_spent**](docs/DefaultApi.md#wallet_spent) | **POST** /api/v1/wallet/spend | +*DefaultApi* | [**wallet_transaction**](docs/DefaultApi.md#wallet_transaction) | **POST** /api/v1/wallet/transaction | +*DefaultApi* | [**wallet_transactions**](docs/DefaultApi.md#wallet_transactions) | **GET** /api/v1/wallet/transactions | +*DefaultApi* | [**wallet_unload**](docs/DefaultApi.md#wallet_unload) | **POST** /api/v1/wallet/unload | Unloads wallet from the wallet service. +*DefaultApi* | [**wallet_update**](docs/DefaultApi.md#wallet_update) | **POST** /api/v1/wallet/update | Update the wallet. +*DefaultApi* | [**wallets**](docs/DefaultApi.md#wallets) | **GET** /api/v1/wallets | + + +## Documentation For Models + + - [Apiv1exploreraddressInputs](docs/Apiv1exploreraddressInputs.md) + - [Apiv1exploreraddressOutputs](docs/Apiv1exploreraddressOutputs.md) + - [Apiv1exploreraddressStatus](docs/Apiv1exploreraddressStatus.md) + - [Apiv1pendingTxsTransaction](docs/Apiv1pendingTxsTransaction.md) + - [Apiv1walletsEntries](docs/Apiv1walletsEntries.md) + - [Apiv1walletsMeta](docs/Apiv1walletsMeta.md) + - [Apiv1wallettransactionHoursSelection](docs/Apiv1wallettransactionHoursSelection.md) + - [Apiv1wallettransactionTo](docs/Apiv1wallettransactionTo.md) + - [Apiv1wallettransactionWallet](docs/Apiv1wallettransactionWallet.md) + - [InlineObject](docs/InlineObject.md) + - [InlineResponse200](docs/InlineResponse200.md) + - [InlineResponse2001](docs/InlineResponse2001.md) + - [InlineResponse2002](docs/InlineResponse2002.md) + - [InlineResponse2003](docs/InlineResponse2003.md) + - [InlineResponse2003UnconfirmedVerifyTransaction](docs/InlineResponse2003UnconfirmedVerifyTransaction.md) + - [InlineResponse2004](docs/InlineResponse2004.md) + - [InlineResponse2005](docs/InlineResponse2005.md) + - [InlineResponse2006](docs/InlineResponse2006.md) + - [InlineResponse2007](docs/InlineResponse2007.md) + - [InlineResponse2007Data](docs/InlineResponse2007Data.md) + - [InlineResponseDefault](docs/InlineResponseDefault.md) + + +## Documentation For Authorization + + +## csrfAuth + +- **Type**: API key +- **API key parameter name**: X-CSRF-TOKEN +- **Location**: HTTP header + + +## Author + +skycoin.doe@example.com + + diff --git a/pysky_api/docs/Apiv1exploreraddressInputs.md b/pysky_api/docs/Apiv1exploreraddressInputs.md new file mode 100644 index 00000000..139c04ae --- /dev/null +++ b/pysky_api/docs/Apiv1exploreraddressInputs.md @@ -0,0 +1,14 @@ +# Apiv1exploreraddressInputs + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**owner** | **str** | | [optional] +**hours** | **int** | | [optional] +**calculated_hours** | **int** | | [optional] +**coins** | **str** | | [optional] +**uxid** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1exploreraddressOutputs.md b/pysky_api/docs/Apiv1exploreraddressOutputs.md new file mode 100644 index 00000000..e92876ab --- /dev/null +++ b/pysky_api/docs/Apiv1exploreraddressOutputs.md @@ -0,0 +1,13 @@ +# Apiv1exploreraddressOutputs + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**hours** | **int** | | [optional] +**dst** | **str** | | [optional] +**coins** | **str** | | [optional] +**uxid** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1exploreraddressStatus.md b/pysky_api/docs/Apiv1exploreraddressStatus.md new file mode 100644 index 00000000..f8cafdf9 --- /dev/null +++ b/pysky_api/docs/Apiv1exploreraddressStatus.md @@ -0,0 +1,13 @@ +# Apiv1exploreraddressStatus + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**unconfirmed** | **bool** | | [optional] +**block_seq** | **int** | | [optional] +**label** | **int** | | [optional] +**confirmed** | **bool** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1pendingTxsTransaction.md b/pysky_api/docs/Apiv1pendingTxsTransaction.md new file mode 100644 index 00000000..e752fd51 --- /dev/null +++ b/pysky_api/docs/Apiv1pendingTxsTransaction.md @@ -0,0 +1,17 @@ +# Apiv1pendingTxsTransaction + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**outputs** | [**list[Apiv1exploreraddressOutputs]**](Apiv1exploreraddressOutputs.md) | | [optional] +**inner_hash** | **str** | | [optional] +**inputs** | **list[str]** | | [optional] +**sigs** | **list[str]** | | [optional] +**length** | **int** | | [optional] +**txid** | **str** | | [optional] +**type** | **int** | | [optional] +**timestamp** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1walletsEntries.md b/pysky_api/docs/Apiv1walletsEntries.md new file mode 100644 index 00000000..839490ed --- /dev/null +++ b/pysky_api/docs/Apiv1walletsEntries.md @@ -0,0 +1,11 @@ +# Apiv1walletsEntries + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**public_key** | **str** | | [optional] +**address** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1walletsMeta.md b/pysky_api/docs/Apiv1walletsMeta.md new file mode 100644 index 00000000..51aa9834 --- /dev/null +++ b/pysky_api/docs/Apiv1walletsMeta.md @@ -0,0 +1,17 @@ +# Apiv1walletsMeta + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**filename** | **str** | | [optional] +**encrypted** | **bool** | | [optional] +**crypto_type** | **str** | | [optional] +**label** | **str** | | [optional] +**type** | **str** | | [optional] +**version** | **str** | | [optional] +**coin** | **str** | | [optional] +**timestamp** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1wallettransactionHoursSelection.md b/pysky_api/docs/Apiv1wallettransactionHoursSelection.md new file mode 100644 index 00000000..164b319e --- /dev/null +++ b/pysky_api/docs/Apiv1wallettransactionHoursSelection.md @@ -0,0 +1,12 @@ +# Apiv1wallettransactionHoursSelection + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**mode** | **str** | | [optional] +**share_factor** | **str** | | [optional] +**type** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1wallettransactionTo.md b/pysky_api/docs/Apiv1wallettransactionTo.md new file mode 100644 index 00000000..d7b40677 --- /dev/null +++ b/pysky_api/docs/Apiv1wallettransactionTo.md @@ -0,0 +1,12 @@ +# Apiv1wallettransactionTo + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**hours** | **int** | | [optional] +**address** | **str** | | [optional] +**coins** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/Apiv1wallettransactionWallet.md b/pysky_api/docs/Apiv1wallettransactionWallet.md new file mode 100644 index 00000000..3efe79b9 --- /dev/null +++ b/pysky_api/docs/Apiv1wallettransactionWallet.md @@ -0,0 +1,13 @@ +# Apiv1wallettransactionWallet + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**unspents** | **list[str]** | | [optional] +**addresses** | **list[str]** | | [optional] +**password** | **str** | | [optional] +**id** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/DefaultApi.md b/pysky_api/docs/DefaultApi.md new file mode 100644 index 00000000..58aa2041 --- /dev/null +++ b/pysky_api/docs/DefaultApi.md @@ -0,0 +1,2597 @@ +# openapi_client.DefaultApi + +All URIs are relative to *http://127.0.0.1:6420* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**address_count**](DefaultApi.md#address_count) | **GET** /api/v1/addresscount | Returns the total number of unique address that have coins. +[**address_uxouts**](DefaultApi.md#address_uxouts) | **GET** /api/v1/address_uxouts | +[**balance_get**](DefaultApi.md#balance_get) | **GET** /api/v1/balance | Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +[**balance_post**](DefaultApi.md#balance_post) | **POST** /api/v1/balance | Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +[**block**](DefaultApi.md#block) | **GET** /api/v1/block | +[**blockchain_metadata**](DefaultApi.md#blockchain_metadata) | **GET** /api/v1/blockchain/metadata | Returns the blockchain metadata. +[**blockchain_progress**](DefaultApi.md#blockchain_progress) | **GET** /api/v1/blockchain/progress | Returns the blockchain sync progress. +[**blocks_get**](DefaultApi.md#blocks_get) | **GET** /api/v1/blocks | blocksHandler returns blocks between a start and end point, +[**blocks_post**](DefaultApi.md#blocks_post) | **POST** /api/v1/blocks | blocksHandler returns blocks between a start and end point, +[**coin_supply**](DefaultApi.md#coin_supply) | **GET** /api/v1/coinSupply | +[**csrf**](DefaultApi.md#csrf) | **GET** /api/v1/csrf | Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. +[**default_connections**](DefaultApi.md#default_connections) | **GET** /api/v1/network/defaultConnections | defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. +[**explorer_address**](DefaultApi.md#explorer_address) | **GET** /api/v1/explorer/address | +[**health**](DefaultApi.md#health) | **GET** /api/v1/health | Returns node health data. +[**last_blocks**](DefaultApi.md#last_blocks) | **GET** /api/v1/last_blocks | +[**network_connection**](DefaultApi.md#network_connection) | **GET** /api/v1/network/connection | This endpoint returns a specific connection. +[**network_connections**](DefaultApi.md#network_connections) | **GET** /api/v1/network/connections | This endpoint returns all outgoings connections. +[**network_connections_disconnect**](DefaultApi.md#network_connections_disconnect) | **POST** /api/v1/network/connection/disconnect | +[**network_connections_exchange**](DefaultApi.md#network_connections_exchange) | **GET** /api/v1/network/connections/exchange | +[**network_connections_trust**](DefaultApi.md#network_connections_trust) | **GET** /api/v1/network/connections/trust | trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. +[**outputs_get**](DefaultApi.md#outputs_get) | **GET** /api/v1/outputs | If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. +[**outputs_post**](DefaultApi.md#outputs_post) | **POST** /api/v1/outputs | If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. +[**pending_txs**](DefaultApi.md#pending_txs) | **GET** /api/v1/pendingTxs | +[**resend_unconfirmed_txns**](DefaultApi.md#resend_unconfirmed_txns) | **POST** /api/v1/resendUnconfirmedTxns | +[**richlist**](DefaultApi.md#richlist) | **GET** /api/v1/richlist | Returns the top skycoin holders. +[**transaction**](DefaultApi.md#transaction) | **GET** /api/v1/transaction | +[**transaction_inject**](DefaultApi.md#transaction_inject) | **POST** /api/v2/transaction/inject | Broadcast a hex-encoded, serialized transaction to the network. +[**transaction_raw**](DefaultApi.md#transaction_raw) | **GET** /api/v2/transaction/raw | Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. +[**transaction_verify**](DefaultApi.md#transaction_verify) | **POST** /api/v2/transaction/verify | +[**transactions_get**](DefaultApi.md#transactions_get) | **GET** /api/v1/transactions | Returns transactions that match the filters. +[**transactions_post**](DefaultApi.md#transactions_post) | **POST** /api/v1/transactions | Returns transactions that match the filters. +[**uxout**](DefaultApi.md#uxout) | **GET** /api/v1/uxout | Returns an unspent output by ID. +[**verify_address**](DefaultApi.md#verify_address) | **POST** /api/v2/address/verify | Verifies a Skycoin address. +[**version**](DefaultApi.md#version) | **GET** /api/v1/version | +[**wallet**](DefaultApi.md#wallet) | **GET** /api/v1/wallet | Returns a wallet by id. +[**wallet_balance**](DefaultApi.md#wallet_balance) | **GET** /api/v1/wallet/balance | Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. +[**wallet_create**](DefaultApi.md#wallet_create) | **POST** /api/v1/wallet/create | +[**wallet_decrypt**](DefaultApi.md#wallet_decrypt) | **POST** /api/v1/wallet/decrypt | Decrypts wallet. +[**wallet_encrypt**](DefaultApi.md#wallet_encrypt) | **POST** /api/v1/wallet/encrypt | Encrypt wallet. +[**wallet_folder**](DefaultApi.md#wallet_folder) | **GET** /api/v1/wallets/folderName | +[**wallet_new_address**](DefaultApi.md#wallet_new_address) | **POST** /api/v1/wallet/newAddress | +[**wallet_new_seed**](DefaultApi.md#wallet_new_seed) | **GET** /api/v1/wallet/newSeed | +[**wallet_recover**](DefaultApi.md#wallet_recover) | **POST** /api/v2/wallet/recover | Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. +[**wallet_seed**](DefaultApi.md#wallet_seed) | **POST** /api/v1/wallet/seed | This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. +[**wallet_seed_verify**](DefaultApi.md#wallet_seed_verify) | **POST** /api/v2/wallet/seed/verify | Verifies a wallet seed. +[**wallet_spent**](DefaultApi.md#wallet_spent) | **POST** /api/v1/wallet/spend | +[**wallet_transaction**](DefaultApi.md#wallet_transaction) | **POST** /api/v1/wallet/transaction | +[**wallet_transactions**](DefaultApi.md#wallet_transactions) | **GET** /api/v1/wallet/transactions | +[**wallet_unload**](DefaultApi.md#wallet_unload) | **POST** /api/v1/wallet/unload | Unloads wallet from the wallet service. +[**wallet_update**](DefaultApi.md#wallet_update) | **POST** /api/v1/wallet/update | Update the wallet. +[**wallets**](DefaultApi.md#wallets) | **GET** /api/v1/wallets | + + +# **address_count** +> object address_count() + +Returns the total number of unique address that have coins. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # Returns the total number of unique address that have coins. + api_response = api_instance.address_count() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->address_count: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **address_uxouts** +> list[InlineResponse200] address_uxouts(address) + + + +Returns the historical, spent outputs associated with an address + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +address = 'address_example' # str | address to filter by + +try: + api_response = api_instance.address_uxouts(address) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->address_uxouts: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **address** | **str**| address to filter by | + +### Return type + +[**list[InlineResponse200]**](InlineResponse200.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **balance_get** +> object balance_get(addrs) + +Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +addrs = 'addrs_example' # str | command separated list of addresses + +try: + # Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + api_response = api_instance.balance_get(addrs) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->balance_get: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addrs** | **str**| command separated list of addresses | + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **balance_post** +> object balance_post(addrs) + +Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +addrs = 'addrs_example' # str | command separated list of addresses + +try: + # Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + api_response = api_instance.balance_post(addrs) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->balance_post: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addrs** | **str**| command separated list of addresses | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **block** +> object block(hash=hash, seq=seq) + + + +Returns a block by hash or seq. Note: only one of hash or seq is allowed + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +hash = 'hash_example' # str | (optional) +seq = 56 # int | (optional) + +try: + api_response = api_instance.block(hash=hash, seq=seq) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->block: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **hash** | **str**| | [optional] + **seq** | **int**| | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **blockchain_metadata** +> object blockchain_metadata() + +Returns the blockchain metadata. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # Returns the blockchain metadata. + api_response = api_instance.blockchain_metadata() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->blockchain_metadata: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **blockchain_progress** +> object blockchain_progress() + +Returns the blockchain sync progress. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # Returns the blockchain sync progress. + api_response = api_instance.blockchain_progress() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->blockchain_progress: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **blocks_get** +> object blocks_get(start=start, end=end, seqs=seqs) + +blocksHandler returns blocks between a start and end point, + +or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +start = 56 # int | (optional) +end = 56 # int | (optional) +seqs = [56] # list[int] | (optional) + +try: + # blocksHandler returns blocks between a start and end point, + api_response = api_instance.blocks_get(start=start, end=end, seqs=seqs) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->blocks_get: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **start** | **int**| | [optional] + **end** | **int**| | [optional] + **seqs** | [**list[int]**](int.md)| | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **blocks_post** +> object blocks_post(start=start, end=end, seqs=seqs) + +blocksHandler returns blocks between a start and end point, + +or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +start = 56 # int | (optional) +end = 56 # int | (optional) +seqs = [56] # list[int] | (optional) + +try: + # blocksHandler returns blocks between a start and end point, + api_response = api_instance.blocks_post(start=start, end=end, seqs=seqs) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->blocks_post: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **start** | **int**| | [optional] + **end** | **int**| | [optional] + **seqs** | [**list[int]**](int.md)| | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **coin_supply** +> coin_supply() + + + +coinSupplyHandler returns coin distribution supply stats + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + api_instance.coin_supply() +except ApiException as e: + print("Exception when calling DefaultApi->coin_supply: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **csrf** +> InlineResponse2001 csrf() + +Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. + api_response = api_instance.csrf() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->csrf: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**InlineResponse2001**](InlineResponse2001.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **default_connections** +> list[str] default_connections() + +defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. + api_response = api_instance.default_connections() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->default_connections: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**list[str]** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **explorer_address** +> list[InlineResponse2002] explorer_address(address=address) + + + +Returns all transactions (confirmed and unconfirmed) for an address + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +address = 'address_example' # str | tags to filter by (optional) + +try: + api_response = api_instance.explorer_address(address=address) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->explorer_address: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **address** | **str**| tags to filter by | [optional] + +### Return type + +[**list[InlineResponse2002]**](InlineResponse2002.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **health** +> object health() + +Returns node health data. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + # Returns node health data. + api_response = api_instance.health() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->health: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **last_blocks** +> object last_blocks(num) + + + +Returns the most recent N blocks on the blockchain + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +num = 56 # int | + +try: + api_response = api_instance.last_blocks(num) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->last_blocks: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **num** | **int**| | + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **network_connection** +> InlineResponse2003 network_connection(addr) + +This endpoint returns a specific connection. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +addr = 'addr_example' # str | Address port + +try: + # This endpoint returns a specific connection. + api_response = api_instance.network_connection(addr) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->network_connection: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addr** | **str**| Address port | + +### Return type + +[**InlineResponse2003**](InlineResponse2003.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **network_connections** +> list[InlineResponse2003] network_connections(states=states, direction=direction) + +This endpoint returns all outgoings connections. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +states = 'states_example' # str | Connection status. (optional) +direction = 'direction_example' # str | Direction of the connection. (optional) + +try: + # This endpoint returns all outgoings connections. + api_response = api_instance.network_connections(states=states, direction=direction) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->network_connections: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **states** | **str**| Connection status. | [optional] + **direction** | **str**| Direction of the connection. | [optional] + +### Return type + +[**list[InlineResponse2003]**](InlineResponse2003.md) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **network_connections_disconnect** +> network_connections_disconnect(id) + + + +This endpoint disconnects a connection by ID or address + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Address id. + +try: + api_instance.network_connections_disconnect(id) +except ApiException as e: + print("Exception when calling DefaultApi->network_connections_disconnect: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Address id. | + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **network_connections_exchange** +> list[str] network_connections_exchange() + + + +This endpoint returns all connections found through peer exchange + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + api_response = api_instance.network_connections_exchange() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->network_connections_exchange: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**list[str]** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **network_connections_trust** +> list[str] network_connections_trust() + +trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) + +try: + # trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. + api_response = api_instance.network_connections_trust() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->network_connections_trust: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**list[str]** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **outputs_get** +> object outputs_get(address=address, hash=hash) + +If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +address = ['address_example'] # list[str] | (optional) +hash = ['hash_example'] # list[str] | (optional) + +try: + # If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. + api_response = api_instance.outputs_get(address=address, hash=hash) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->outputs_get: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **address** | [**list[str]**](str.md)| | [optional] + **hash** | [**list[str]**](str.md)| | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **outputs_post** +> object outputs_post(address=address, hash=hash) + +If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +address = 'address_example' # str | (optional) +hash = 'hash_example' # str | (optional) + +try: + # If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. + api_response = api_instance.outputs_post(address=address, hash=hash) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->outputs_post: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **address** | **str**| | [optional] + **hash** | **str**| | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **pending_txs** +> list[InlineResponse2004] pending_txs() + + + +Returns pending (unconfirmed) transactions without verbose + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + api_response = api_instance.pending_txs() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->pending_txs: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**list[InlineResponse2004]**](InlineResponse2004.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **resend_unconfirmed_txns** +> resend_unconfirmed_txns() + + + +Broadcasts all unconfirmed transactions from the unconfirmed transaction pool + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) + +try: + api_instance.resend_unconfirmed_txns() +except ApiException as e: + print("Exception when calling DefaultApi->resend_unconfirmed_txns: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **richlist** +> object richlist(include_distribution=include_distribution, n=n) + +Returns the top skycoin holders. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +include_distribution = True # bool | include distribution addresses or not, default value false (optional) +n = 'n_example' # str | include distribution addresses or not, default value false (optional) + +try: + # Returns the top skycoin holders. + api_response = api_instance.richlist(include_distribution=include_distribution, n=n) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->richlist: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **include_distribution** | **bool**| include distribution addresses or not, default value false | [optional] + **n** | **str**| include distribution addresses or not, default value false | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transaction** +> object transaction(txid, encoded=encoded) + + + +Returns a transaction identified by its txid hash with just id + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +txid = 'txid_example' # str | transaction hash +encoded = True # bool | return as a raw encoded transaction. (optional) + +try: + api_response = api_instance.transaction(txid, encoded=encoded) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transaction: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **txid** | **str**| transaction hash | + **encoded** | **bool**| return as a raw encoded transaction. | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transaction_inject** +> object transaction_inject(rawtx) + +Broadcast a hex-encoded, serialized transaction to the network. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +rawtx = 'rawtx_example' # str | hex-encoded serialized transaction string. + +try: + # Broadcast a hex-encoded, serialized transaction to the network. + api_response = api_instance.transaction_inject(rawtx) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transaction_inject: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **rawtx** | **str**| hex-encoded serialized transaction string. | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transaction_raw** +> object transaction_raw(txid=txid) + +Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +txid = 'txid_example' # str | Transaction id hash (optional) + +try: + # Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. + api_response = api_instance.transaction_raw(txid=txid) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transaction_raw: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **txid** | **str**| Transaction id hash | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transaction_verify** +> object transaction_verify() + + + +Decode and verify an encoded transaction + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) + +try: + api_response = api_instance.transaction_verify() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transaction_verify: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transactions_get** +> object transactions_get(addrs=addrs, confirmed=confirmed) + +Returns transactions that match the filters. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +addrs = 'addrs_example' # str | command separated list of addresses (optional) +confirmed = 'confirmed_example' # str | Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] (optional) + +try: + # Returns transactions that match the filters. + api_response = api_instance.transactions_get(addrs=addrs, confirmed=confirmed) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transactions_get: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addrs** | **str**| command separated list of addresses | [optional] + **confirmed** | **str**| Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **transactions_post** +> object transactions_post(addrs=addrs, confirmed=confirmed) + +Returns transactions that match the filters. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +addrs = 'addrs_example' # str | command separated list of addresses (optional) +confirmed = 'confirmed_example' # str | Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] (optional) + +try: + # Returns transactions that match the filters. + api_response = api_instance.transactions_post(addrs=addrs, confirmed=confirmed) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->transactions_post: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addrs** | **str**| command separated list of addresses | [optional] + **confirmed** | **str**| Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **uxout** +> object uxout(uxid=uxid) + +Returns an unspent output by ID. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +uxid = 'uxid_example' # str | uxid to filter by (optional) + +try: + # Returns an unspent output by ID. + api_response = api_instance.uxout(uxid=uxid) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->uxout: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **uxid** | **str**| uxid to filter by | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **verify_address** +> InlineResponse2007 verify_address(address) + +Verifies a Skycoin address. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +address = 'address_example' # str | Address id. + +try: + # Verifies a Skycoin address. + api_response = api_instance.verify_address(address) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->verify_address: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **address** | **str**| Address id. | + +### Return type + +[**InlineResponse2007**](InlineResponse2007.md) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **version** +> version() + + + +versionHandler returns the application version info + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + api_instance.version() +except ApiException as e: + print("Exception when calling DefaultApi->version: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +void (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet** +> object wallet(id) + +Returns a wallet by id. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +id = 'id_example' # str | tags to filter by + +try: + # Returns a wallet by id. + api_response = api_instance.wallet(id) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| tags to filter by | + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_balance** +> object wallet_balance(id) + +Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +id = 'id_example' # str | tags to filter by + +try: + # Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. + api_response = api_instance.wallet_balance(id) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_balance: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| tags to filter by | + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_create** +> object wallet_create(seed, label, scan=scan, encrypt=encrypt, password=password) + + + +Loads wallet from seed, will scan ahead N address and load addresses till the last one that have coins. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +seed = 'seed_example' # str | Wallet seed. +label = 'label_example' # str | Wallet label. +scan = 56 # int | The number of addresses to scan ahead for balances. (optional) +encrypt = True # bool | Encrypt wallet. (optional) +password = 'password_example' # str | Wallet Password (optional) + +try: + api_response = api_instance.wallet_create(seed, label, scan=scan, encrypt=encrypt, password=password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_create: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **seed** | **str**| Wallet seed. | + **label** | **str**| Wallet label. | + **scan** | **int**| The number of addresses to scan ahead for balances. | [optional] + **encrypt** | **bool**| Encrypt wallet. | [optional] + **password** | **str**| Wallet Password | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_decrypt** +> object wallet_decrypt(id, password) + +Decrypts wallet. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet id. +password = 'password_example' # str | Wallet password. + +try: + # Decrypts wallet. + api_response = api_instance.wallet_decrypt(id, password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_decrypt: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet id. | + **password** | **str**| Wallet password. | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_encrypt** +> object wallet_encrypt(id, password) + +Encrypt wallet. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet id. +password = 'password_example' # str | Wallet password. + +try: + # Encrypt wallet. + api_response = api_instance.wallet_encrypt(id, password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_encrypt: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet id. | + **password** | **str**| Wallet password. | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_folder** +> InlineResponse2006 wallet_folder(addr) + + + +Returns the wallet directory path + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +addr = 'addr_example' # str | Address port + +try: + api_response = api_instance.wallet_folder(addr) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_folder: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **addr** | **str**| Address port | + +### Return type + +[**InlineResponse2006**](InlineResponse2006.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_new_address** +> object wallet_new_address(id, num=num, password=password) + + + +Generates new addresses + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet Id +num = 'num_example' # str | The number you want to generate (optional) +password = 'password_example' # str | Wallet Password (optional) + +try: + api_response = api_instance.wallet_new_address(id, num=num, password=password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_new_address: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet Id | + **num** | **str**| The number you want to generate | [optional] + **password** | **str**| Wallet Password | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_new_seed** +> object wallet_new_seed(entropy=entropy) + + + +Returns the wallet directory path + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +entropy = 'entropy_example' # str | Entropy bitSize. (optional) + +try: + api_response = api_instance.wallet_new_seed(entropy=entropy) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_new_seed: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **entropy** | **str**| Entropy bitSize. | [optional] + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_recover** +> object wallet_recover(id, seed, password=password) + +Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet id. +seed = 'seed_example' # str | Wallet seed. +password = 'password_example' # str | Wallet password. (optional) + +try: + # Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. + api_response = api_instance.wallet_recover(id, seed, password=password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_recover: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet id. | + **seed** | **str**| Wallet seed. | + **password** | **str**| Wallet password. | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_seed** +> object wallet_seed(id, password) + +This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet Id. +password = 'password_example' # str | Wallet password. + +try: + # This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. + api_response = api_instance.wallet_seed(id, password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_seed: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet Id. | + **password** | **str**| Wallet password. | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_seed_verify** +> object wallet_seed_verify(seed=seed) + +Verifies a wallet seed. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +seed = 'seed_example' # str | Seed to be verified. (optional) + +try: + # Verifies a wallet seed. + api_response = api_instance.wallet_seed_verify(seed=seed) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_seed_verify: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **seed** | **str**| Seed to be verified. | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_spent** +> object wallet_spent(id, dst, coins, password) + + + +Creates and broadcasts a transaction sending money from one of our wallets to destination address. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet id +dst = 'dst_example' # str | Recipient address +coins = 'coins_example' # str | Number of coins to spend, in droplets. 1 coin equals 1e6 droplets. +password = 'password_example' # str | Wallet password. + +try: + api_response = api_instance.wallet_spent(id, dst, coins, password) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_spent: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet id | + **dst** | **str**| Recipient address | + **coins** | **str**| Number of coins to spend, in droplets. 1 coin equals 1e6 droplets. | + **password** | **str**| Wallet password. | + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_transaction** +> object wallet_transaction(inline_object=inline_object) + + + +Creates a signed transaction + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +inline_object = openapi_client.InlineObject() # InlineObject | (optional) + +try: + api_response = api_instance.wallet_transaction(inline_object=inline_object) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_transaction: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **inline_object** | [**InlineObject**](InlineObject.md)| | [optional] + +### Return type + +**object** + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: application/json, application/xml + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_transactions** +> object wallet_transactions(id) + + + +Returns returns all unconfirmed transactions for all addresses in a given wallet verbose + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() +id = 'id_example' # str | Wallet id. + +try: + api_response = api_instance.wallet_transactions(id) + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_transactions: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet id. | + +### Return type + +**object** + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_unload** +> wallet_unload(id) + +Unloads wallet from the wallet service. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet Id. + +try: + # Unloads wallet from the wallet service. + api_instance.wallet_unload(id) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_unload: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet Id. | + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallet_update** +> wallet_update(id, label) + +Update the wallet. + +### Example + +* Api Key Authentication (csrfAuth): +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# Configure API key authorization: csrfAuth +configuration = openapi_client.Configuration() +configuration.api_key['X-CSRF-TOKEN'] = 'YOUR_API_KEY' +# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed +# configuration.api_key_prefix['X-CSRF-TOKEN'] = 'Bearer' + +# create an instance of the API class +api_instance = openapi_client.DefaultApi(openapi_client.ApiClient(configuration)) +id = 'id_example' # str | Wallet Id. +label = 'label_example' # str | The label the wallet will be updated to. + +try: + # Update the wallet. + api_instance.wallet_update(id, label) +except ApiException as e: + print("Exception when calling DefaultApi->wallet_update: %s\n" % e) +``` + +### Parameters + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **id** | **str**| Wallet Id. | + **label** | **str**| The label the wallet will be updated to. | + +### Return type + +void (empty response body) + +### Authorization + +[csrfAuth](../README.md#csrfAuth) + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **wallets** +> list[InlineResponse2005] wallets() + + + +Returns all loaded wallets + +### Example +```python +from __future__ import print_function +import time +import openapi_client +from openapi_client.rest import ApiException +from pprint import pprint + +# create an instance of the API class +api_instance = openapi_client.DefaultApi() + +try: + api_response = api_instance.wallets() + pprint(api_response) +except ApiException as e: + print("Exception when calling DefaultApi->wallets: %s\n" % e) +``` + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**list[InlineResponse2005]**](InlineResponse2005.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/pysky_api/docs/InlineObject.md b/pysky_api/docs/InlineObject.md new file mode 100644 index 00000000..a4b44b2a --- /dev/null +++ b/pysky_api/docs/InlineObject.md @@ -0,0 +1,14 @@ +# InlineObject + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**change_address** | **str** | | [optional] +**hours_selection** | [**Apiv1wallettransactionHoursSelection**](Apiv1wallettransactionHoursSelection.md) | | [optional] +**ignore_unconfirmed** | **bool** | | [optional] +**to** | [**list[Apiv1wallettransactionTo]**](Apiv1wallettransactionTo.md) | | [optional] +**wallet** | [**Apiv1wallettransactionWallet**](Apiv1wallettransactionWallet.md) | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse200.md b/pysky_api/docs/InlineResponse200.md new file mode 100644 index 00000000..2c467671 --- /dev/null +++ b/pysky_api/docs/InlineResponse200.md @@ -0,0 +1,18 @@ +# InlineResponse200 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**hours** | **int** | | [optional] +**coins** | **int** | | [optional] +**uxid** | **str** | | [optional] +**owner_address** | **str** | | [optional] +**spent_block_seq** | **int** | | [optional] +**spent_tx** | **str** | | [optional] +**time** | **int** | | [optional] +**src_block_seq** | **int** | | [optional] +**src_tx** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2001.md b/pysky_api/docs/InlineResponse2001.md new file mode 100644 index 00000000..003d55d3 --- /dev/null +++ b/pysky_api/docs/InlineResponse2001.md @@ -0,0 +1,10 @@ +# InlineResponse2001 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**csrf_token** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2002.md b/pysky_api/docs/InlineResponse2002.md new file mode 100644 index 00000000..88ee3bc4 --- /dev/null +++ b/pysky_api/docs/InlineResponse2002.md @@ -0,0 +1,19 @@ +# InlineResponse2002 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**outputs** | [**list[Apiv1exploreraddressOutputs]**](Apiv1exploreraddressOutputs.md) | | [optional] +**inner_hash** | **str** | | [optional] +**inputs** | [**list[Apiv1exploreraddressInputs]**](Apiv1exploreraddressInputs.md) | | [optional] +**fee** | **int** | | [optional] +**sigs** | **list[str]** | | [optional] +**length** | **int** | | [optional] +**txid** | **str** | | [optional] +**type** | **int** | | [optional] +**status** | [**Apiv1exploreraddressStatus**](Apiv1exploreraddressStatus.md) | | [optional] +**timestamp** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2003.md b/pysky_api/docs/InlineResponse2003.md new file mode 100644 index 00000000..49c13820 --- /dev/null +++ b/pysky_api/docs/InlineResponse2003.md @@ -0,0 +1,22 @@ +# InlineResponse2003 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**last_received** | **int** | | [optional] +**last_sent** | **int** | | [optional] +**outgoing** | **bool** | | [optional] +**mirror** | **int** | | [optional] +**address** | **str** | | [optional] +**listen_port** | **int** | | [optional] +**is_trusted_peer** | **bool** | | [optional] +**connected_at** | **int** | | [optional] +**unconfirmed_verify_transaction** | [**InlineResponse2003UnconfirmedVerifyTransaction**](InlineResponse2003UnconfirmedVerifyTransaction.md) | | [optional] +**id** | **int** | | [optional] +**state** | **str** | | [optional] +**user_agent** | **str** | | [optional] +**height** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md b/pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md new file mode 100644 index 00000000..a5254d47 --- /dev/null +++ b/pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md @@ -0,0 +1,12 @@ +# InlineResponse2003UnconfirmedVerifyTransaction + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**burn_factor** | **int** | | [optional] +**max_transaction_size** | **int** | | [optional] +**max_decimals** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2004.md b/pysky_api/docs/InlineResponse2004.md new file mode 100644 index 00000000..8626c010 --- /dev/null +++ b/pysky_api/docs/InlineResponse2004.md @@ -0,0 +1,14 @@ +# InlineResponse2004 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**announced** | **str** | | [optional] +**is_valid** | **bool** | | [optional] +**checked** | **str** | | [optional] +**received** | **str** | | [optional] +**transaction** | [**Apiv1pendingTxsTransaction**](Apiv1pendingTxsTransaction.md) | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2005.md b/pysky_api/docs/InlineResponse2005.md new file mode 100644 index 00000000..911db166 --- /dev/null +++ b/pysky_api/docs/InlineResponse2005.md @@ -0,0 +1,11 @@ +# InlineResponse2005 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**entries** | [**list[Apiv1walletsEntries]**](Apiv1walletsEntries.md) | | [optional] +**meta** | [**Apiv1walletsMeta**](Apiv1walletsMeta.md) | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2006.md b/pysky_api/docs/InlineResponse2006.md new file mode 100644 index 00000000..845f9d17 --- /dev/null +++ b/pysky_api/docs/InlineResponse2006.md @@ -0,0 +1,10 @@ +# InlineResponse2006 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**address** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2007.md b/pysky_api/docs/InlineResponse2007.md new file mode 100644 index 00000000..42c3c027 --- /dev/null +++ b/pysky_api/docs/InlineResponse2007.md @@ -0,0 +1,11 @@ +# InlineResponse2007 + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**data** | [**InlineResponse2007Data**](InlineResponse2007Data.md) | | [optional] +**error** | [**object**](.md) | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponse2007Data.md b/pysky_api/docs/InlineResponse2007Data.md new file mode 100644 index 00000000..3d6b0d35 --- /dev/null +++ b/pysky_api/docs/InlineResponse2007Data.md @@ -0,0 +1,10 @@ +# InlineResponse2007Data + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**version** | **int** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/docs/InlineResponseDefault.md b/pysky_api/docs/InlineResponseDefault.md new file mode 100644 index 00000000..2862e401 --- /dev/null +++ b/pysky_api/docs/InlineResponseDefault.md @@ -0,0 +1,11 @@ +# InlineResponseDefault + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**code** | **int** | | [optional] +**message** | **str** | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/pysky_api/git_push.sh b/pysky_api/git_push.sh new file mode 100644 index 00000000..8442b80b --- /dev/null +++ b/pysky_api/git_push.sh @@ -0,0 +1,52 @@ +#!/bin/sh +# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/ +# +# Usage example: /bin/sh ./git_push.sh wing328 openapi-pestore-perl "minor update" + +git_user_id=$1 +git_repo_id=$2 +release_note=$3 + +if [ "$git_user_id" = "" ]; then + git_user_id="GIT_USER_ID" + echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id" +fi + +if [ "$git_repo_id" = "" ]; then + git_repo_id="GIT_REPO_ID" + echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id" +fi + +if [ "$release_note" = "" ]; then + release_note="Minor update" + echo "[INFO] No command line input provided. Set \$release_note to $release_note" +fi + +# Initialize the local directory as a Git repository +git init + +# Adds the files in the local repository and stages them for commit. +git add . + +# Commits the tracked changes and prepares them to be pushed to a remote repository. +git commit -m "$release_note" + +# Sets the new remote +git_remote=`git remote` +if [ "$git_remote" = "" ]; then # git remote not defined + + if [ "$GIT_TOKEN" = "" ]; then + echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment." + git remote add origin https://github.com/${git_user_id}/${git_repo_id}.git + else + git remote add origin https://${git_user_id}:${GIT_TOKEN}@github.com/${git_user_id}/${git_repo_id}.git + fi + +fi + +git pull origin master + +# Pushes (Forces) the changes in the local repository up to the remote repository +echo "Git pushing to https://github.com/${git_user_id}/${git_repo_id}.git" +git push origin master 2>&1 | grep -v 'To https' + diff --git a/pysky_api/openapi_client/__init__.py b/pysky_api/openapi_client/__init__.py new file mode 100644 index 00000000..f05ad86b --- /dev/null +++ b/pysky_api/openapi_client/__init__.py @@ -0,0 +1,47 @@ +# coding: utf-8 + +# flake8: noqa + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +__version__ = "1.0.0" + +# import apis into sdk package +from openapi_client.api.default_api import DefaultApi + +# import ApiClient +from openapi_client.api_client import ApiClient +from openapi_client.configuration import Configuration +# import models into sdk package +from openapi_client.models.apiv1exploreraddress_inputs import Apiv1exploreraddressInputs +from openapi_client.models.apiv1exploreraddress_outputs import Apiv1exploreraddressOutputs +from openapi_client.models.apiv1exploreraddress_status import Apiv1exploreraddressStatus +from openapi_client.models.apiv1pending_txs_transaction import Apiv1pendingTxsTransaction +from openapi_client.models.apiv1wallets_entries import Apiv1walletsEntries +from openapi_client.models.apiv1wallets_meta import Apiv1walletsMeta +from openapi_client.models.apiv1wallettransaction_hours_selection import Apiv1wallettransactionHoursSelection +from openapi_client.models.apiv1wallettransaction_to import Apiv1wallettransactionTo +from openapi_client.models.apiv1wallettransaction_wallet import Apiv1wallettransactionWallet +from openapi_client.models.inline_object import InlineObject +from openapi_client.models.inline_response200 import InlineResponse200 +from openapi_client.models.inline_response2001 import InlineResponse2001 +from openapi_client.models.inline_response2002 import InlineResponse2002 +from openapi_client.models.inline_response2003 import InlineResponse2003 +from openapi_client.models.inline_response2003_unconfirmed_verify_transaction import InlineResponse2003UnconfirmedVerifyTransaction +from openapi_client.models.inline_response2004 import InlineResponse2004 +from openapi_client.models.inline_response2005 import InlineResponse2005 +from openapi_client.models.inline_response2006 import InlineResponse2006 +from openapi_client.models.inline_response2007 import InlineResponse2007 +from openapi_client.models.inline_response2007_data import InlineResponse2007Data +from openapi_client.models.inline_response_default import InlineResponseDefault diff --git a/pysky_api/openapi_client/api/__init__.py b/pysky_api/openapi_client/api/__init__.py new file mode 100644 index 00000000..c8f7c0ca --- /dev/null +++ b/pysky_api/openapi_client/api/__init__.py @@ -0,0 +1,6 @@ +from __future__ import absolute_import + +# flake8: noqa + +# import apis into api package +from openapi_client.api.default_api import DefaultApi diff --git a/pysky_api/openapi_client/api/default_api.py b/pysky_api/openapi_client/api/default_api.py new file mode 100644 index 00000000..36440413 --- /dev/null +++ b/pysky_api/openapi_client/api/default_api.py @@ -0,0 +1,4854 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import re # noqa: F401 + +# python 2 and python 3 compatibility library +import six + +from openapi_client.api_client import ApiClient + + +class DefaultApi(object): + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None): + if api_client is None: + api_client = ApiClient() + self.api_client = api_client + + def address_count(self, **kwargs): # noqa: E501 + """Returns the total number of unique address that have coins. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.address_count(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.address_count_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.address_count_with_http_info(**kwargs) # noqa: E501 + return data + + def address_count_with_http_info(self, **kwargs): # noqa: E501 + """Returns the total number of unique address that have coins. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.address_count_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method address_count" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/addresscount', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def address_uxouts(self, address, **kwargs): # noqa: E501 + """address_uxouts # noqa: E501 + + Returns the historical, spent outputs associated with an address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.address_uxouts(address, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: address to filter by (required) + :return: list[InlineResponse200] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.address_uxouts_with_http_info(address, **kwargs) # noqa: E501 + else: + (data) = self.address_uxouts_with_http_info(address, **kwargs) # noqa: E501 + return data + + def address_uxouts_with_http_info(self, address, **kwargs): # noqa: E501 + """address_uxouts # noqa: E501 + + Returns the historical, spent outputs associated with an address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.address_uxouts_with_http_info(address, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: address to filter by (required) + :return: list[InlineResponse200] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['address'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method address_uxouts" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'address' is set + if ('address' not in local_var_params or + local_var_params['address'] is None): + raise ValueError("Missing the required parameter `address` when calling `address_uxouts`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'address' in local_var_params: + query_params.append(('address', local_var_params['address'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/address_uxouts', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse200]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def balance_get(self, addrs, **kwargs): # noqa: E501 + """Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.balance_get(addrs, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.balance_get_with_http_info(addrs, **kwargs) # noqa: E501 + else: + (data) = self.balance_get_with_http_info(addrs, **kwargs) # noqa: E501 + return data + + def balance_get_with_http_info(self, addrs, **kwargs): # noqa: E501 + """Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.balance_get_with_http_info(addrs, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addrs'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method balance_get" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'addrs' is set + if ('addrs' not in local_var_params or + local_var_params['addrs'] is None): + raise ValueError("Missing the required parameter `addrs` when calling `balance_get`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addrs' in local_var_params: + query_params.append(('addrs', local_var_params['addrs'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/balance', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def balance_post(self, addrs, **kwargs): # noqa: E501 + """Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.balance_post(addrs, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.balance_post_with_http_info(addrs, **kwargs) # noqa: E501 + else: + (data) = self.balance_post_with_http_info(addrs, **kwargs) # noqa: E501 + return data + + def balance_post_with_http_info(self, addrs, **kwargs): # noqa: E501 + """Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.balance_post_with_http_info(addrs, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addrs'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method balance_post" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'addrs' is set + if ('addrs' not in local_var_params or + local_var_params['addrs'] is None): + raise ValueError("Missing the required parameter `addrs` when calling `balance_post`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addrs' in local_var_params: + query_params.append(('addrs', local_var_params['addrs'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/balance', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def block(self, **kwargs): # noqa: E501 + """block # noqa: E501 + + Returns a block by hash or seq. Note: only one of hash or seq is allowed # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.block(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str hash: + :param int seq: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.block_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.block_with_http_info(**kwargs) # noqa: E501 + return data + + def block_with_http_info(self, **kwargs): # noqa: E501 + """block # noqa: E501 + + Returns a block by hash or seq. Note: only one of hash or seq is allowed # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.block_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str hash: + :param int seq: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['hash', 'seq'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method block" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'hash' in local_var_params: + query_params.append(('hash', local_var_params['hash'])) # noqa: E501 + if 'seq' in local_var_params: + query_params.append(('seq', local_var_params['seq'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/block', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def blockchain_metadata(self, **kwargs): # noqa: E501 + """Returns the blockchain metadata. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blockchain_metadata(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.blockchain_metadata_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.blockchain_metadata_with_http_info(**kwargs) # noqa: E501 + return data + + def blockchain_metadata_with_http_info(self, **kwargs): # noqa: E501 + """Returns the blockchain metadata. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blockchain_metadata_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method blockchain_metadata" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/blockchain/metadata', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def blockchain_progress(self, **kwargs): # noqa: E501 + """Returns the blockchain sync progress. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blockchain_progress(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.blockchain_progress_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.blockchain_progress_with_http_info(**kwargs) # noqa: E501 + return data + + def blockchain_progress_with_http_info(self, **kwargs): # noqa: E501 + """Returns the blockchain sync progress. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blockchain_progress_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method blockchain_progress" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/blockchain/progress', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def blocks_get(self, **kwargs): # noqa: E501 + """blocksHandler returns blocks between a start and end point, # noqa: E501 + + or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blocks_get(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int start: + :param int end: + :param list[int] seqs: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.blocks_get_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.blocks_get_with_http_info(**kwargs) # noqa: E501 + return data + + def blocks_get_with_http_info(self, **kwargs): # noqa: E501 + """blocksHandler returns blocks between a start and end point, # noqa: E501 + + or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blocks_get_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int start: + :param int end: + :param list[int] seqs: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['start', 'end', 'seqs'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method blocks_get" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'start' in local_var_params: + query_params.append(('start', local_var_params['start'])) # noqa: E501 + if 'end' in local_var_params: + query_params.append(('end', local_var_params['end'])) # noqa: E501 + if 'seqs' in local_var_params: + query_params.append(('seqs', local_var_params['seqs'])) # noqa: E501 + collection_formats['seqs'] = 'csv' # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/blocks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def blocks_post(self, **kwargs): # noqa: E501 + """blocksHandler returns blocks between a start and end point, # noqa: E501 + + or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blocks_post(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int start: + :param int end: + :param list[int] seqs: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.blocks_post_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.blocks_post_with_http_info(**kwargs) # noqa: E501 + return data + + def blocks_post_with_http_info(self, **kwargs): # noqa: E501 + """blocksHandler returns blocks between a start and end point, # noqa: E501 + + or an explicit list of sequences. If using start and end, the block sequences include both the start and end point. Explicit sequences cannot be combined with start and end. Without verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.blocks_post_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int start: + :param int end: + :param list[int] seqs: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['start', 'end', 'seqs'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method blocks_post" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'start' in local_var_params: + query_params.append(('start', local_var_params['start'])) # noqa: E501 + if 'end' in local_var_params: + query_params.append(('end', local_var_params['end'])) # noqa: E501 + if 'seqs' in local_var_params: + query_params.append(('seqs', local_var_params['seqs'])) # noqa: E501 + collection_formats['seqs'] = 'csv' # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/blocks', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def coin_supply(self, **kwargs): # noqa: E501 + """coin_supply # noqa: E501 + + coinSupplyHandler returns coin distribution supply stats # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.coin_supply(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.coin_supply_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.coin_supply_with_http_info(**kwargs) # noqa: E501 + return data + + def coin_supply_with_http_info(self, **kwargs): # noqa: E501 + """coin_supply # noqa: E501 + + coinSupplyHandler returns coin distribution supply stats # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.coin_supply_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method coin_supply" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/coinSupply', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def csrf(self, **kwargs): # noqa: E501 + """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.csrf(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2001 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.csrf_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.csrf_with_http_info(**kwargs) # noqa: E501 + return data + + def csrf_with_http_info(self, **kwargs): # noqa: E501 + """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.csrf_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: InlineResponse2001 + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method csrf" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/csrf', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2001', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def default_connections(self, **kwargs): # noqa: E501 + """defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.default_connections(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.default_connections_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.default_connections_with_http_info(**kwargs) # noqa: E501 + return data + + def default_connections_with_http_info(self, **kwargs): # noqa: E501 + """defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.default_connections_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method default_connections" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/defaultConnections', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[str]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def explorer_address(self, **kwargs): # noqa: E501 + """explorer_address # noqa: E501 + + Returns all transactions (confirmed and unconfirmed) for an address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.explorer_address(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: tags to filter by + :return: list[InlineResponse2002] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.explorer_address_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.explorer_address_with_http_info(**kwargs) # noqa: E501 + return data + + def explorer_address_with_http_info(self, **kwargs): # noqa: E501 + """explorer_address # noqa: E501 + + Returns all transactions (confirmed and unconfirmed) for an address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.explorer_address_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: tags to filter by + :return: list[InlineResponse2002] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['address'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method explorer_address" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'address' in local_var_params: + query_params.append(('address', local_var_params['address'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/explorer/address', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2002]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def health(self, **kwargs): # noqa: E501 + """Returns node health data. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.health(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.health_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.health_with_http_info(**kwargs) # noqa: E501 + return data + + def health_with_http_info(self, **kwargs): # noqa: E501 + """Returns node health data. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.health_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method health" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/health', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def last_blocks(self, num, **kwargs): # noqa: E501 + """last_blocks # noqa: E501 + + Returns the most recent N blocks on the blockchain # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.last_blocks(num, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int num: (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.last_blocks_with_http_info(num, **kwargs) # noqa: E501 + else: + (data) = self.last_blocks_with_http_info(num, **kwargs) # noqa: E501 + return data + + def last_blocks_with_http_info(self, num, **kwargs): # noqa: E501 + """last_blocks # noqa: E501 + + Returns the most recent N blocks on the blockchain # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.last_blocks_with_http_info(num, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param int num: (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['num'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method last_blocks" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'num' is set + if ('num' not in local_var_params or + local_var_params['num'] is None): + raise ValueError("Missing the required parameter `num` when calling `last_blocks`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'num' in local_var_params: + query_params.append(('num', local_var_params['num'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/last_blocks', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def network_connection(self, addr, **kwargs): # noqa: E501 + """This endpoint returns a specific connection. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connection(addr, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addr: Address port (required) + :return: InlineResponse2003 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.network_connection_with_http_info(addr, **kwargs) # noqa: E501 + else: + (data) = self.network_connection_with_http_info(addr, **kwargs) # noqa: E501 + return data + + def network_connection_with_http_info(self, addr, **kwargs): # noqa: E501 + """This endpoint returns a specific connection. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connection_with_http_info(addr, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addr: Address port (required) + :return: InlineResponse2003 + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addr'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method network_connection" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'addr' is set + if ('addr' not in local_var_params or + local_var_params['addr'] is None): + raise ValueError("Missing the required parameter `addr` when calling `network_connection`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addr' in local_var_params: + query_params.append(('addr', local_var_params['addr'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/connection', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2003', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def network_connections(self, **kwargs): # noqa: E501 + """This endpoint returns all outgoings connections. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str states: Connection status. + :param str direction: Direction of the connection. + :return: list[InlineResponse2003] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.network_connections_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.network_connections_with_http_info(**kwargs) # noqa: E501 + return data + + def network_connections_with_http_info(self, **kwargs): # noqa: E501 + """This endpoint returns all outgoings connections. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str states: Connection status. + :param str direction: Direction of the connection. + :return: list[InlineResponse2003] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['states', 'direction'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method network_connections" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'states' in local_var_params: + query_params.append(('states', local_var_params['states'])) # noqa: E501 + if 'direction' in local_var_params: + query_params.append(('direction', local_var_params['direction'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/connections', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2003]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def network_connections_disconnect(self, id, **kwargs): # noqa: E501 + """network_connections_disconnect # noqa: E501 + + This endpoint disconnects a connection by ID or address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_disconnect(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Address id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.network_connections_disconnect_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.network_connections_disconnect_with_http_info(id, **kwargs) # noqa: E501 + return data + + def network_connections_disconnect_with_http_info(self, id, **kwargs): # noqa: E501 + """network_connections_disconnect # noqa: E501 + + This endpoint disconnects a connection by ID or address # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_disconnect_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Address id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method network_connections_disconnect" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `network_connections_disconnect`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/connection/disconnect', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def network_connections_exchange(self, **kwargs): # noqa: E501 + """network_connections_exchange # noqa: E501 + + This endpoint returns all connections found through peer exchange # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_exchange(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.network_connections_exchange_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.network_connections_exchange_with_http_info(**kwargs) # noqa: E501 + return data + + def network_connections_exchange_with_http_info(self, **kwargs): # noqa: E501 + """network_connections_exchange # noqa: E501 + + This endpoint returns all connections found through peer exchange # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_exchange_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method network_connections_exchange" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/connections/exchange', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[str]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def network_connections_trust(self, **kwargs): # noqa: E501 + """trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_trust(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.network_connections_trust_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.network_connections_trust_with_http_info(**kwargs) # noqa: E501 + return data + + def network_connections_trust_with_http_info(self, **kwargs): # noqa: E501 + """trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.network_connections_trust_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[str] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method network_connections_trust" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/network/connections/trust', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[str]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def outputs_get(self, **kwargs): # noqa: E501 + """If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.outputs_get(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param list[str] address: + :param list[str] hash: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.outputs_get_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.outputs_get_with_http_info(**kwargs) # noqa: E501 + return data + + def outputs_get_with_http_info(self, **kwargs): # noqa: E501 + """If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.outputs_get_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param list[str] address: + :param list[str] hash: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['address', 'hash'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method outputs_get" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'address' in local_var_params: + query_params.append(('address', local_var_params['address'])) # noqa: E501 + collection_formats['address'] = 'csv' # noqa: E501 + if 'hash' in local_var_params: + query_params.append(('hash', local_var_params['hash'])) # noqa: E501 + collection_formats['hash'] = 'csv' # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/outputs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def outputs_post(self, **kwargs): # noqa: E501 + """If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.outputs_post(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: + :param str hash: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.outputs_post_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.outputs_post_with_http_info(**kwargs) # noqa: E501 + return data + + def outputs_post_with_http_info(self, **kwargs): # noqa: E501 + """If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.outputs_post_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: + :param str hash: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['address', 'hash'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method outputs_post" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'address' in local_var_params: + query_params.append(('address', local_var_params['address'])) # noqa: E501 + if 'hash' in local_var_params: + query_params.append(('hash', local_var_params['hash'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/outputs', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def pending_txs(self, **kwargs): # noqa: E501 + """pending_txs # noqa: E501 + + Returns pending (unconfirmed) transactions without verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.pending_txs(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[InlineResponse2004] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.pending_txs_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.pending_txs_with_http_info(**kwargs) # noqa: E501 + return data + + def pending_txs_with_http_info(self, **kwargs): # noqa: E501 + """pending_txs # noqa: E501 + + Returns pending (unconfirmed) transactions without verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.pending_txs_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[InlineResponse2004] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method pending_txs" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/pendingTxs', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2004]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def resend_unconfirmed_txns(self, **kwargs): # noqa: E501 + """resend_unconfirmed_txns # noqa: E501 + + Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.resend_unconfirmed_txns(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 + return data + + def resend_unconfirmed_txns_with_http_info(self, **kwargs): # noqa: E501 + """resend_unconfirmed_txns # noqa: E501 + + Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.resend_unconfirmed_txns_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method resend_unconfirmed_txns" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/resendUnconfirmedTxns', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def richlist(self, **kwargs): # noqa: E501 + """Returns the top skycoin holders. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.richlist(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool include_distribution: include distribution addresses or not, default value false + :param str n: include distribution addresses or not, default value false + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.richlist_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.richlist_with_http_info(**kwargs) # noqa: E501 + return data + + def richlist_with_http_info(self, **kwargs): # noqa: E501 + """Returns the top skycoin holders. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.richlist_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param bool include_distribution: include distribution addresses or not, default value false + :param str n: include distribution addresses or not, default value false + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['include_distribution', 'n'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method richlist" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'include_distribution' in local_var_params: + query_params.append(('include-distribution', local_var_params['include_distribution'])) # noqa: E501 + if 'n' in local_var_params: + query_params.append(('n', local_var_params['n'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/richlist', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transaction(self, txid, **kwargs): # noqa: E501 + """transaction # noqa: E501 + + Returns a transaction identified by its txid hash with just id # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction(txid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str txid: transaction hash (required) + :param bool encoded: return as a raw encoded transaction. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transaction_with_http_info(txid, **kwargs) # noqa: E501 + else: + (data) = self.transaction_with_http_info(txid, **kwargs) # noqa: E501 + return data + + def transaction_with_http_info(self, txid, **kwargs): # noqa: E501 + """transaction # noqa: E501 + + Returns a transaction identified by its txid hash with just id # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_with_http_info(txid, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str txid: transaction hash (required) + :param bool encoded: return as a raw encoded transaction. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['txid', 'encoded'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transaction" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'txid' is set + if ('txid' not in local_var_params or + local_var_params['txid'] is None): + raise ValueError("Missing the required parameter `txid` when calling `transaction`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'txid' in local_var_params: + query_params.append(('txid', local_var_params['txid'])) # noqa: E501 + if 'encoded' in local_var_params: + query_params.append(('encoded', local_var_params['encoded'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/transaction', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transaction_inject(self, rawtx, **kwargs): # noqa: E501 + """Broadcast a hex-encoded, serialized transaction to the network. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_inject(rawtx, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str rawtx: hex-encoded serialized transaction string. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transaction_inject_with_http_info(rawtx, **kwargs) # noqa: E501 + else: + (data) = self.transaction_inject_with_http_info(rawtx, **kwargs) # noqa: E501 + return data + + def transaction_inject_with_http_info(self, rawtx, **kwargs): # noqa: E501 + """Broadcast a hex-encoded, serialized transaction to the network. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_inject_with_http_info(rawtx, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str rawtx: hex-encoded serialized transaction string. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['rawtx'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transaction_inject" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'rawtx' is set + if ('rawtx' not in local_var_params or + local_var_params['rawtx'] is None): + raise ValueError("Missing the required parameter `rawtx` when calling `transaction_inject`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'rawtx' in local_var_params: + header_params['rawtx'] = local_var_params['rawtx'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/transaction/inject', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transaction_raw(self, **kwargs): # noqa: E501 + """Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_raw(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str txid: Transaction id hash + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transaction_raw_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.transaction_raw_with_http_info(**kwargs) # noqa: E501 + return data + + def transaction_raw_with_http_info(self, **kwargs): # noqa: E501 + """Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_raw_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str txid: Transaction id hash + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['txid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transaction_raw" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'txid' in local_var_params: + query_params.append(('txid', local_var_params['txid'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/transaction/raw', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transaction_verify(self, **kwargs): # noqa: E501 + """transaction_verify # noqa: E501 + + Decode and verify an encoded transaction # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_verify(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transaction_verify_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.transaction_verify_with_http_info(**kwargs) # noqa: E501 + return data + + def transaction_verify_with_http_info(self, **kwargs): # noqa: E501 + """transaction_verify # noqa: E501 + + Decode and verify an encoded transaction # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transaction_verify_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transaction_verify" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/transaction/verify', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transactions_get(self, **kwargs): # noqa: E501 + """Returns transactions that match the filters. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transactions_get(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses + :param str confirmed: Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transactions_get_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.transactions_get_with_http_info(**kwargs) # noqa: E501 + return data + + def transactions_get_with_http_info(self, **kwargs): # noqa: E501 + """Returns transactions that match the filters. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transactions_get_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses + :param str confirmed: Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addrs', 'confirmed'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transactions_get" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addrs' in local_var_params: + query_params.append(('addrs', local_var_params['addrs'])) # noqa: E501 + if 'confirmed' in local_var_params: + query_params.append(('confirmed', local_var_params['confirmed'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/transactions', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def transactions_post(self, **kwargs): # noqa: E501 + """Returns transactions that match the filters. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transactions_post(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses + :param str confirmed: Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.transactions_post_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.transactions_post_with_http_info(**kwargs) # noqa: E501 + return data + + def transactions_post_with_http_info(self, **kwargs): # noqa: E501 + """Returns transactions that match the filters. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.transactions_post_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addrs: command separated list of addresses + :param str confirmed: Whether the transactions should be confirmed [optional, must be 0 or 1; if not provided, returns all] + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addrs', 'confirmed'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method transactions_post" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addrs' in local_var_params: + query_params.append(('addrs', local_var_params['addrs'])) # noqa: E501 + if 'confirmed' in local_var_params: + query_params.append(('confirmed', local_var_params['confirmed'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/transactions', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def uxout(self, **kwargs): # noqa: E501 + """Returns an unspent output by ID. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.uxout(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str uxid: uxid to filter by + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.uxout_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.uxout_with_http_info(**kwargs) # noqa: E501 + return data + + def uxout_with_http_info(self, **kwargs): # noqa: E501 + """Returns an unspent output by ID. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.uxout_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str uxid: uxid to filter by + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['uxid'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method uxout" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'uxid' in local_var_params: + query_params.append(('uxid', local_var_params['uxid'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/uxout', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def verify_address(self, address, **kwargs): # noqa: E501 + """Verifies a Skycoin address. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.verify_address(address, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: Address id. (required) + :return: InlineResponse2007 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.verify_address_with_http_info(address, **kwargs) # noqa: E501 + else: + (data) = self.verify_address_with_http_info(address, **kwargs) # noqa: E501 + return data + + def verify_address_with_http_info(self, address, **kwargs): # noqa: E501 + """Verifies a Skycoin address. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.verify_address_with_http_info(address, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str address: Address id. (required) + :return: InlineResponse2007 + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['address'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method verify_address" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'address' is set + if ('address' not in local_var_params or + local_var_params['address'] is None): + raise ValueError("Missing the required parameter `address` when calling `verify_address`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'address' in local_var_params: + query_params.append(('address', local_var_params['address'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/address/verify', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2007', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def version(self, **kwargs): # noqa: E501 + """version # noqa: E501 + + versionHandler returns the application version info # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.version(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.version_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.version_with_http_info(**kwargs) # noqa: E501 + return data + + def version_with_http_info(self, **kwargs): # noqa: E501 + """version # noqa: E501 + + versionHandler returns the application version info # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.version_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method version" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/version', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet(self, id, **kwargs): # noqa: E501 + """Returns a wallet by id. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: tags to filter by (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.wallet_with_http_info(id, **kwargs) # noqa: E501 + return data + + def wallet_with_http_info(self, id, **kwargs): # noqa: E501 + """Returns a wallet by id. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: tags to filter by (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_balance(self, id, **kwargs): # noqa: E501 + """Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_balance(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: tags to filter by (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_balance_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.wallet_balance_with_http_info(id, **kwargs) # noqa: E501 + return data + + def wallet_balance_with_http_info(self, id, **kwargs): # noqa: E501 + """Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_balance_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: tags to filter by (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_balance" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_balance`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/balance', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_create(self, seed, label, **kwargs): # noqa: E501 + """wallet_create # noqa: E501 + + Loads wallet from seed, will scan ahead N address and load addresses till the last one that have coins. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_create(seed, label, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str seed: Wallet seed. (required) + :param str label: Wallet label. (required) + :param int scan: The number of addresses to scan ahead for balances. + :param bool encrypt: Encrypt wallet. + :param str password: Wallet Password + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_create_with_http_info(seed, label, **kwargs) # noqa: E501 + else: + (data) = self.wallet_create_with_http_info(seed, label, **kwargs) # noqa: E501 + return data + + def wallet_create_with_http_info(self, seed, label, **kwargs): # noqa: E501 + """wallet_create # noqa: E501 + + Loads wallet from seed, will scan ahead N address and load addresses till the last one that have coins. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_create_with_http_info(seed, label, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str seed: Wallet seed. (required) + :param str label: Wallet label. (required) + :param int scan: The number of addresses to scan ahead for balances. + :param bool encrypt: Encrypt wallet. + :param str password: Wallet Password + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['seed', 'label', 'scan', 'encrypt', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_create" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'seed' is set + if ('seed' not in local_var_params or + local_var_params['seed'] is None): + raise ValueError("Missing the required parameter `seed` when calling `wallet_create`") # noqa: E501 + # verify the required parameter 'label' is set + if ('label' not in local_var_params or + local_var_params['label'] is None): + raise ValueError("Missing the required parameter `label` when calling `wallet_create`") # noqa: E501 + + if 'scan' in local_var_params and local_var_params['scan'] < 1: # noqa: E501 + raise ValueError("Invalid value for parameter `scan` when calling `wallet_create`, must be a value greater than or equal to `1`") # noqa: E501 + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'seed' in local_var_params: + header_params['seed'] = local_var_params['seed'] # noqa: E501 + if 'label' in local_var_params: + header_params['label'] = local_var_params['label'] # noqa: E501 + if 'scan' in local_var_params: + header_params['scan'] = local_var_params['scan'] # noqa: E501 + if 'encrypt' in local_var_params: + header_params['encrypt'] = local_var_params['encrypt'] # noqa: E501 + if 'password' in local_var_params: + header_params['password'] = local_var_params['password'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/create', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_decrypt(self, id, password, **kwargs): # noqa: E501 + """Decrypts wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_decrypt(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_decrypt_with_http_info(id, password, **kwargs) # noqa: E501 + else: + (data) = self.wallet_decrypt_with_http_info(id, password, **kwargs) # noqa: E501 + return data + + def wallet_decrypt_with_http_info(self, id, password, **kwargs): # noqa: E501 + """Decrypts wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_decrypt_with_http_info(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_decrypt" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_decrypt`") # noqa: E501 + # verify the required parameter 'password' is set + if ('password' not in local_var_params or + local_var_params['password'] is None): + raise ValueError("Missing the required parameter `password` when calling `wallet_decrypt`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'id' in local_var_params: + header_params['id'] = local_var_params['id'] # noqa: E501 + if 'password' in local_var_params: + header_params['password'] = local_var_params['password'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/decrypt', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_encrypt(self, id, password, **kwargs): # noqa: E501 + """Encrypt wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_encrypt(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_encrypt_with_http_info(id, password, **kwargs) # noqa: E501 + else: + (data) = self.wallet_encrypt_with_http_info(id, password, **kwargs) # noqa: E501 + return data + + def wallet_encrypt_with_http_info(self, id, password, **kwargs): # noqa: E501 + """Encrypt wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_encrypt_with_http_info(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_encrypt" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_encrypt`") # noqa: E501 + # verify the required parameter 'password' is set + if ('password' not in local_var_params or + local_var_params['password'] is None): + raise ValueError("Missing the required parameter `password` when calling `wallet_encrypt`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'id' in local_var_params: + header_params['id'] = local_var_params['id'] # noqa: E501 + if 'password' in local_var_params: + header_params['password'] = local_var_params['password'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/encrypt', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_folder(self, addr, **kwargs): # noqa: E501 + """wallet_folder # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_folder(addr, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addr: Address port (required) + :return: InlineResponse2006 + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_folder_with_http_info(addr, **kwargs) # noqa: E501 + else: + (data) = self.wallet_folder_with_http_info(addr, **kwargs) # noqa: E501 + return data + + def wallet_folder_with_http_info(self, addr, **kwargs): # noqa: E501 + """wallet_folder # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_folder_with_http_info(addr, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str addr: Address port (required) + :return: InlineResponse2006 + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['addr'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_folder" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'addr' is set + if ('addr' not in local_var_params or + local_var_params['addr'] is None): + raise ValueError("Missing the required parameter `addr` when calling `wallet_folder`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'addr' in local_var_params: + query_params.append(('addr', local_var_params['addr'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallets/folderName', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='InlineResponse2006', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_new_address(self, id, **kwargs): # noqa: E501 + """wallet_new_address # noqa: E501 + + Generates new addresses # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_new_address(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id (required) + :param str num: The number you want to generate + :param str password: Wallet Password + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_new_address_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.wallet_new_address_with_http_info(id, **kwargs) # noqa: E501 + return data + + def wallet_new_address_with_http_info(self, id, **kwargs): # noqa: E501 + """wallet_new_address # noqa: E501 + + Generates new addresses # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_new_address_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id (required) + :param str num: The number you want to generate + :param str password: Wallet Password + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'num', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_new_address" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_new_address`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + if 'num' in local_var_params: + query_params.append(('num', local_var_params['num'])) # noqa: E501 + if 'password' in local_var_params: + query_params.append(('password', local_var_params['password'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/newAddress', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_new_seed(self, **kwargs): # noqa: E501 + """wallet_new_seed # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_new_seed(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entropy: Entropy bitSize. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_new_seed_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.wallet_new_seed_with_http_info(**kwargs) # noqa: E501 + return data + + def wallet_new_seed_with_http_info(self, **kwargs): # noqa: E501 + """wallet_new_seed # noqa: E501 + + Returns the wallet directory path # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_new_seed_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str entropy: Entropy bitSize. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['entropy'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_new_seed" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'entropy' in local_var_params: + query_params.append(('entropy', local_var_params['entropy'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/newSeed', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_recover(self, id, seed, **kwargs): # noqa: E501 + """Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_recover(id, seed, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str seed: Wallet seed. (required) + :param str password: Wallet password. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_recover_with_http_info(id, seed, **kwargs) # noqa: E501 + else: + (data) = self.wallet_recover_with_http_info(id, seed, **kwargs) # noqa: E501 + return data + + def wallet_recover_with_http_info(self, id, seed, **kwargs): # noqa: E501 + """Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_recover_with_http_info(id, seed, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :param str seed: Wallet seed. (required) + :param str password: Wallet password. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'seed', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_recover" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_recover`") # noqa: E501 + # verify the required parameter 'seed' is set + if ('seed' not in local_var_params or + local_var_params['seed'] is None): + raise ValueError("Missing the required parameter `seed` when calling `wallet_recover`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'id' in local_var_params: + header_params['id'] = local_var_params['id'] # noqa: E501 + if 'seed' in local_var_params: + header_params['seed'] = local_var_params['seed'] # noqa: E501 + if 'password' in local_var_params: + header_params['password'] = local_var_params['password'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/wallet/recover', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_seed(self, id, password, **kwargs): # noqa: E501 + """This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_seed(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_seed_with_http_info(id, password, **kwargs) # noqa: E501 + else: + (data) = self.wallet_seed_with_http_info(id, password, **kwargs) # noqa: E501 + return data + + def wallet_seed_with_http_info(self, id, password, **kwargs): # noqa: E501 + """This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_seed_with_http_info(id, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_seed" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_seed`") # noqa: E501 + # verify the required parameter 'password' is set + if ('password' not in local_var_params or + local_var_params['password'] is None): + raise ValueError("Missing the required parameter `password` when calling `wallet_seed`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + if 'password' in local_var_params: + query_params.append(('password', local_var_params['password'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/seed', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_seed_verify(self, **kwargs): # noqa: E501 + """Verifies a wallet seed. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_seed_verify(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str seed: Seed to be verified. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_seed_verify_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.wallet_seed_verify_with_http_info(**kwargs) # noqa: E501 + return data + + def wallet_seed_verify_with_http_info(self, **kwargs): # noqa: E501 + """Verifies a wallet seed. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_seed_verify_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str seed: Seed to be verified. + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['seed'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_seed_verify" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'seed' in local_var_params: + header_params['seed'] = local_var_params['seed'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v2/wallet/seed/verify', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_spent(self, id, dst, coins, password, **kwargs): # noqa: E501 + """wallet_spent # noqa: E501 + + Creates and broadcasts a transaction sending money from one of our wallets to destination address. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_spent(id, dst, coins, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id (required) + :param str dst: Recipient address (required) + :param str coins: Number of coins to spend, in droplets. 1 coin equals 1e6 droplets. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_spent_with_http_info(id, dst, coins, password, **kwargs) # noqa: E501 + else: + (data) = self.wallet_spent_with_http_info(id, dst, coins, password, **kwargs) # noqa: E501 + return data + + def wallet_spent_with_http_info(self, id, dst, coins, password, **kwargs): # noqa: E501 + """wallet_spent # noqa: E501 + + Creates and broadcasts a transaction sending money from one of our wallets to destination address. # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_spent_with_http_info(id, dst, coins, password, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id (required) + :param str dst: Recipient address (required) + :param str coins: Number of coins to spend, in droplets. 1 coin equals 1e6 droplets. (required) + :param str password: Wallet password. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'dst', 'coins', 'password'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_spent" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_spent`") # noqa: E501 + # verify the required parameter 'dst' is set + if ('dst' not in local_var_params or + local_var_params['dst'] is None): + raise ValueError("Missing the required parameter `dst` when calling `wallet_spent`") # noqa: E501 + # verify the required parameter 'coins' is set + if ('coins' not in local_var_params or + local_var_params['coins'] is None): + raise ValueError("Missing the required parameter `coins` when calling `wallet_spent`") # noqa: E501 + # verify the required parameter 'password' is set + if ('password' not in local_var_params or + local_var_params['password'] is None): + raise ValueError("Missing the required parameter `password` when calling `wallet_spent`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'id' in local_var_params: + header_params['id'] = local_var_params['id'] # noqa: E501 + if 'dst' in local_var_params: + header_params['dst'] = local_var_params['dst'] # noqa: E501 + if 'coins' in local_var_params: + header_params['coins'] = local_var_params['coins'] # noqa: E501 + if 'password' in local_var_params: + header_params['password'] = local_var_params['password'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/spend', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_transaction(self, **kwargs): # noqa: E501 + """wallet_transaction # noqa: E501 + + Creates a signed transaction # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_transaction(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param InlineObject inline_object: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_transaction_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.wallet_transaction_with_http_info(**kwargs) # noqa: E501 + return data + + def wallet_transaction_with_http_info(self, **kwargs): # noqa: E501 + """wallet_transaction # noqa: E501 + + Creates a signed transaction # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_transaction_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :param InlineObject inline_object: + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['inline_object'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_transaction" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + if 'inline_object' in local_var_params: + body_params = local_var_params['inline_object'] + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # HTTP header `Content-Type` + header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 + ['application/json', 'application/xml']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/transaction', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_transactions(self, id, **kwargs): # noqa: E501 + """wallet_transactions # noqa: E501 + + Returns returns all unconfirmed transactions for all addresses in a given wallet verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_transactions(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_transactions_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.wallet_transactions_with_http_info(id, **kwargs) # noqa: E501 + return data + + def wallet_transactions_with_http_info(self, id, **kwargs): # noqa: E501 + """wallet_transactions # noqa: E501 + + Returns returns all unconfirmed transactions for all addresses in a given wallet verbose # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_transactions_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet id. (required) + :return: object + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_transactions" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_transactions`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/transactions', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='object', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_unload(self, id, **kwargs): # noqa: E501 + """Unloads wallet from the wallet service. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_unload(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_unload_with_http_info(id, **kwargs) # noqa: E501 + else: + (data) = self.wallet_unload_with_http_info(id, **kwargs) # noqa: E501 + return data + + def wallet_unload_with_http_info(self, id, **kwargs): # noqa: E501 + """Unloads wallet from the wallet service. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_unload_with_http_info(id, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_unload" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_unload`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + if 'id' in local_var_params: + query_params.append(('id', local_var_params['id'])) # noqa: E501 + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/unload', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallet_update(self, id, label, **kwargs): # noqa: E501 + """Update the wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_update(id, label, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :param str label: The label the wallet will be updated to. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallet_update_with_http_info(id, label, **kwargs) # noqa: E501 + else: + (data) = self.wallet_update_with_http_info(id, label, **kwargs) # noqa: E501 + return data + + def wallet_update_with_http_info(self, id, label, **kwargs): # noqa: E501 + """Update the wallet. # noqa: E501 + + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallet_update_with_http_info(id, label, async_req=True) + >>> result = thread.get() + + :param async_req bool + :param str id: Wallet Id. (required) + :param str label: The label the wallet will be updated to. (required) + :return: None + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = ['id', 'label'] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallet_update" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + # verify the required parameter 'id' is set + if ('id' not in local_var_params or + local_var_params['id'] is None): + raise ValueError("Missing the required parameter `id` when calling `wallet_update`") # noqa: E501 + # verify the required parameter 'label' is set + if ('label' not in local_var_params or + local_var_params['label'] is None): + raise ValueError("Missing the required parameter `label` when calling `wallet_update`") # noqa: E501 + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + if 'id' in local_var_params: + header_params['id'] = local_var_params['id'] # noqa: E501 + if 'label' in local_var_params: + header_params['label'] = local_var_params['label'] # noqa: E501 + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = ['csrfAuth'] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallet/update', 'POST', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type=None, # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) + + def wallets(self, **kwargs): # noqa: E501 + """wallets # noqa: E501 + + Returns all loaded wallets # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallets(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[InlineResponse2005] + If the method is called asynchronously, + returns the request thread. + """ + kwargs['_return_http_data_only'] = True + if kwargs.get('async_req'): + return self.wallets_with_http_info(**kwargs) # noqa: E501 + else: + (data) = self.wallets_with_http_info(**kwargs) # noqa: E501 + return data + + def wallets_with_http_info(self, **kwargs): # noqa: E501 + """wallets # noqa: E501 + + Returns all loaded wallets # noqa: E501 + This method makes a synchronous HTTP request by default. To make an + asynchronous HTTP request, please pass async_req=True + >>> thread = api.wallets_with_http_info(async_req=True) + >>> result = thread.get() + + :param async_req bool + :return: list[InlineResponse2005] + If the method is called asynchronously, + returns the request thread. + """ + + local_var_params = locals() + + all_params = [] # noqa: E501 + all_params.append('async_req') + all_params.append('_return_http_data_only') + all_params.append('_preload_content') + all_params.append('_request_timeout') + + for key, val in six.iteritems(local_var_params['kwargs']): + if key not in all_params: + raise TypeError( + "Got an unexpected keyword argument '%s'" + " to method wallets" % key + ) + local_var_params[key] = val + del local_var_params['kwargs'] + + collection_formats = {} + + path_params = {} + + query_params = [] + + header_params = {} + + form_params = [] + local_var_files = {} + + body_params = None + # HTTP header `Accept` + header_params['Accept'] = self.api_client.select_header_accept( + ['application/json']) # noqa: E501 + + # Authentication setting + auth_settings = [] # noqa: E501 + + return self.api_client.call_api( + '/api/v1/wallets', 'GET', + path_params, + query_params, + header_params, + body=body_params, + post_params=form_params, + files=local_var_files, + response_type='list[InlineResponse2005]', # noqa: E501 + auth_settings=auth_settings, + async_req=local_var_params.get('async_req'), + _return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501 + _preload_content=local_var_params.get('_preload_content', True), + _request_timeout=local_var_params.get('_request_timeout'), + collection_formats=collection_formats) diff --git a/pysky_api/openapi_client/api_client.py b/pysky_api/openapi_client/api_client.py new file mode 100644 index 00000000..af4f8264 --- /dev/null +++ b/pysky_api/openapi_client/api_client.py @@ -0,0 +1,635 @@ +# coding: utf-8 +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + +from __future__ import absolute_import + +import datetime +import json +import mimetypes +from multiprocessing.pool import ThreadPool +import os +import re +import tempfile + +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import quote + +from openapi_client.configuration import Configuration +import openapi_client.models +from openapi_client import rest + + +class ApiClient(object): + """Generic API client for OpenAPI client library builds. + + OpenAPI generic API client. This client handles the client- + server communication, and is invariant across implementations. Specifics of + the methods and models for each application are generated from the OpenAPI + templates. + + NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + Do not edit the class manually. + + :param configuration: .Configuration object for this client + :param header_name: a header to pass when making calls to the API. + :param header_value: a header value to pass when making calls to + the API. + :param cookie: a cookie to include in the header when making calls + to the API + :param pool_threads: The number of threads to use for async requests + to the API. More threads means more concurrent API requests. + """ + + PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types + NATIVE_TYPES_MAPPING = { + 'int': int, + 'long': int if six.PY3 else long, # noqa: F821 + 'float': float, + 'str': str, + 'bool': bool, + 'date': datetime.date, + 'datetime': datetime.datetime, + 'object': object, + } + _pool = None + + def __init__(self, configuration=None, header_name=None, header_value=None, + cookie=None, pool_threads=None): + if configuration is None: + configuration = Configuration() + self.configuration = configuration + self.pool_threads = pool_threads + + self.rest_client = rest.RESTClientObject(configuration) + self.default_headers = {} + if header_name is not None: + self.default_headers[header_name] = header_value + self.cookie = cookie + # Set default User-Agent. + self.user_agent = 'OpenAPI-Generator/1.0.0/python' + + def __del__(self): + if self._pool: + self._pool.close() + self._pool.join() + self._pool = None + + @property + def pool(self): + """Create thread pool on first request + avoids instantiating unused threadpool for blocking clients. + """ + if self._pool is None: + self._pool = ThreadPool(self.pool_threads) + return self._pool + + @property + def user_agent(self): + """User agent for this API client""" + return self.default_headers['User-Agent'] + + @user_agent.setter + def user_agent(self, value): + self.default_headers['User-Agent'] = value + + def set_default_header(self, header_name, header_value): + self.default_headers[header_name] = header_value + + def __call_api( + self, resource_path, method, path_params=None, + query_params=None, header_params=None, body=None, post_params=None, + files=None, response_type=None, auth_settings=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + + config = self.configuration + + # header parameters + header_params = header_params or {} + header_params.update(self.default_headers) + if self.cookie: + header_params['Cookie'] = self.cookie + if header_params: + header_params = self.sanitize_for_serialization(header_params) + header_params = dict(self.parameters_to_tuples(header_params, + collection_formats)) + + # path parameters + if path_params: + path_params = self.sanitize_for_serialization(path_params) + path_params = self.parameters_to_tuples(path_params, + collection_formats) + for k, v in path_params: + # specified safe chars, encode everything + resource_path = resource_path.replace( + '{%s}' % k, + quote(str(v), safe=config.safe_chars_for_path_param) + ) + + # query parameters + if query_params: + query_params = self.sanitize_for_serialization(query_params) + query_params = self.parameters_to_tuples(query_params, + collection_formats) + + # post parameters + if post_params or files: + post_params = self.prepare_post_parameters(post_params, files) + post_params = self.sanitize_for_serialization(post_params) + post_params = self.parameters_to_tuples(post_params, + collection_formats) + + # auth setting + self.update_params_for_auth(header_params, query_params, auth_settings) + + # body + if body: + body = self.sanitize_for_serialization(body) + + # request url + url = self.configuration.host + resource_path + + # perform request and return response + response_data = self.request( + method, url, query_params=query_params, headers=header_params, + post_params=post_params, body=body, + _preload_content=_preload_content, + _request_timeout=_request_timeout) + + self.last_response = response_data + + return_data = response_data + if _preload_content: + # deserialize response data + if response_type: + return_data = self.deserialize(response_data, response_type) + else: + return_data = None + + if _return_http_data_only: + return (return_data) + else: + return (return_data, response_data.status, + response_data.getheaders()) + + def sanitize_for_serialization(self, obj): + """Builds a JSON POST object. + + If obj is None, return None. + If obj is str, int, long, float, bool, return directly. + If obj is datetime.datetime, datetime.date + convert to string in iso8601 format. + If obj is list, sanitize each element in the list. + If obj is dict, return the dict. + If obj is OpenAPI model, return the properties dict. + + :param obj: The data to serialize. + :return: The serialized form of data. + """ + if obj is None: + return None + elif isinstance(obj, self.PRIMITIVE_TYPES): + return obj + elif isinstance(obj, list): + return [self.sanitize_for_serialization(sub_obj) + for sub_obj in obj] + elif isinstance(obj, tuple): + return tuple(self.sanitize_for_serialization(sub_obj) + for sub_obj in obj) + elif isinstance(obj, (datetime.datetime, datetime.date)): + return obj.isoformat() + + if isinstance(obj, dict): + obj_dict = obj + else: + # Convert model obj to dict except + # attributes `openapi_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + obj_dict = {obj.attribute_map[attr]: getattr(obj, attr) + for attr, _ in six.iteritems(obj.openapi_types) + if getattr(obj, attr) is not None} + + return {key: self.sanitize_for_serialization(val) + for key, val in six.iteritems(obj_dict)} + + def deserialize(self, response, response_type): + """Deserializes response into an object. + + :param response: RESTResponse object to be deserialized. + :param response_type: class literal for + deserialized object, or string of class name. + + :return: deserialized object. + """ + # handle file downloading + # save response body into a tmp file and return the instance + if response_type == "file": + return self.__deserialize_file(response) + + # fetch data from response object + try: + data = json.loads(response.data) + except ValueError: + data = response.data + + return self.__deserialize(data, response_type) + + def __deserialize(self, data, klass): + """Deserializes dict, list, str into an object. + + :param data: dict, list or str. + :param klass: class literal, or string of class name. + + :return: object. + """ + if data is None: + return None + + if type(klass) == str: + if klass.startswith('list['): + sub_kls = re.match(r'list\[(.*)\]', klass).group(1) + return [self.__deserialize(sub_data, sub_kls) + for sub_data in data] + + if klass.startswith('dict('): + sub_kls = re.match(r'dict\(([^,]*), (.*)\)', klass).group(2) + return {k: self.__deserialize(v, sub_kls) + for k, v in six.iteritems(data)} + + # convert str to class + if klass in self.NATIVE_TYPES_MAPPING: + klass = self.NATIVE_TYPES_MAPPING[klass] + else: + klass = getattr(openapi_client.models, klass) + + if klass in self.PRIMITIVE_TYPES: + return self.__deserialize_primitive(data, klass) + elif klass == object: + return self.__deserialize_object(data) + elif klass == datetime.date: + return self.__deserialize_date(data) + elif klass == datetime.datetime: + return self.__deserialize_datatime(data) + else: + return self.__deserialize_model(data, klass) + + def call_api(self, resource_path, method, + path_params=None, query_params=None, header_params=None, + body=None, post_params=None, files=None, + response_type=None, auth_settings=None, async_req=None, + _return_http_data_only=None, collection_formats=None, + _preload_content=True, _request_timeout=None): + """Makes the HTTP request (synchronous) and returns deserialized data. + + To make an async_req request, set the async_req parameter. + + :param resource_path: Path to method endpoint. + :param method: Method to call. + :param path_params: Path parameters in the url. + :param query_params: Query parameters in the url. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param auth_settings list: Auth Settings names for the request. + :param response: Response data type. + :param files dict: key -> filename, value -> filepath, + for `multipart/form-data`. + :param async_req bool: execute request asynchronously + :param _return_http_data_only: response data without head status code + and headers + :param collection_formats: dict of collection formats for path, query, + header, and post parameters. + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :return: + If async_req parameter is True, + the request will be called asynchronously. + The method will return the request thread. + If parameter async_req is False or missing, + then the method will return the response directly. + """ + if not async_req: + return self.__call_api(resource_path, method, + path_params, query_params, header_params, + body, post_params, files, + response_type, auth_settings, + _return_http_data_only, collection_formats, + _preload_content, _request_timeout) + else: + thread = self.pool.apply_async(self.__call_api, (resource_path, + method, path_params, query_params, + header_params, body, + post_params, files, + response_type, auth_settings, + _return_http_data_only, + collection_formats, + _preload_content, _request_timeout)) + return thread + + def request(self, method, url, query_params=None, headers=None, + post_params=None, body=None, _preload_content=True, + _request_timeout=None): + """Makes the HTTP request using RESTClient.""" + if method == "GET": + return self.rest_client.GET(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "HEAD": + return self.rest_client.HEAD(url, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + headers=headers) + elif method == "OPTIONS": + return self.rest_client.OPTIONS(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "POST": + return self.rest_client.POST(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PUT": + return self.rest_client.PUT(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "PATCH": + return self.rest_client.PATCH(url, + query_params=query_params, + headers=headers, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + elif method == "DELETE": + return self.rest_client.DELETE(url, + query_params=query_params, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + else: + raise ValueError( + "http method must be `GET`, `HEAD`, `OPTIONS`," + " `POST`, `PATCH`, `PUT` or `DELETE`." + ) + + def parameters_to_tuples(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: Parameters as list of tuples, collections formatted + """ + new_params = [] + if collection_formats is None: + collection_formats = {} + for k, v in six.iteritems(params) if isinstance(params, dict) else params: # noqa: E501 + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, value) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(str(value) for value in v))) + else: + new_params.append((k, v)) + return new_params + + def prepare_post_parameters(self, post_params=None, files=None): + """Builds form parameters. + + :param post_params: Normal form parameters. + :param files: File parameters. + :return: Form parameters with files. + """ + params = [] + + if post_params: + params = post_params + + if files: + for k, v in six.iteritems(files): + if not v: + continue + file_names = v if type(v) is list else [v] + for n in file_names: + with open(n, 'rb') as f: + filename = os.path.basename(f.name) + filedata = f.read() + mimetype = (mimetypes.guess_type(filename)[0] or + 'application/octet-stream') + params.append( + tuple([k, tuple([filename, filedata, mimetype])])) + + return params + + def select_header_accept(self, accepts): + """Returns `Accept` based on an array of accepts provided. + + :param accepts: List of headers. + :return: Accept (e.g. application/json). + """ + if not accepts: + return + + accepts = [x.lower() for x in accepts] + + if 'application/json' in accepts: + return 'application/json' + else: + return ', '.join(accepts) + + def select_header_content_type(self, content_types): + """Returns `Content-Type` based on an array of content_types provided. + + :param content_types: List of content-types. + :return: Content-Type (e.g. application/json). + """ + if not content_types: + return 'application/json' + + content_types = [x.lower() for x in content_types] + + if 'application/json' in content_types or '*/*' in content_types: + return 'application/json' + else: + return content_types[0] + + def update_params_for_auth(self, headers, querys, auth_settings): + """Updates header and query params based on authentication setting. + + :param headers: Header parameters dict to be updated. + :param querys: Query parameters tuple list to be updated. + :param auth_settings: Authentication setting identifiers list. + """ + if not auth_settings: + return + + for auth in auth_settings: + auth_setting = self.configuration.auth_settings().get(auth) + if auth_setting: + if not auth_setting['value']: + continue + elif auth_setting['in'] == 'header': + headers[auth_setting['key']] = auth_setting['value'] + elif auth_setting['in'] == 'query': + querys.append((auth_setting['key'], auth_setting['value'])) + else: + raise ValueError( + 'Authentication token must be in `query` or `header`' + ) + + def __deserialize_file(self, response): + """Deserializes body to file + + Saves response body into a file in a temporary folder, + using the filename from the `Content-Disposition` header if provided. + + :param response: RESTResponse. + :return: file path. + """ + fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) + os.close(fd) + os.remove(path) + + content_disposition = response.getheader("Content-Disposition") + if content_disposition: + filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', + content_disposition).group(1) + path = os.path.join(os.path.dirname(path), filename) + + with open(path, "wb") as f: + f.write(response.data) + + return path + + def __deserialize_primitive(self, data, klass): + """Deserializes string to primitive type. + + :param data: str. + :param klass: class literal. + + :return: int, long, float, str, bool. + """ + try: + return klass(data) + except UnicodeEncodeError: + return six.text_type(data) + except TypeError: + return data + + def __deserialize_object(self, value): + """Return an original value. + + :return: object. + """ + return value + + def __deserialize_date(self, string): + """Deserializes string to date. + + :param string: str. + :return: date. + """ + try: + from dateutil.parser import parse + return parse(string).date() + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason="Failed to parse `{0}` as date object".format(string) + ) + + def __deserialize_datatime(self, string): + """Deserializes string to datetime. + + The string should be in iso8601 datetime format. + + :param string: str. + :return: datetime. + """ + try: + from dateutil.parser import parse + return parse(string) + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as datetime object" + .format(string) + ) + ) + + def __deserialize_model(self, data, klass): + """Deserializes list or dict to model. + + :param data: dict, list. + :param klass: class literal. + :return: model object. + """ + + if not klass.openapi_types and not hasattr(klass, + 'get_real_child_model'): + return data + + kwargs = {} + if klass.openapi_types is not None: + for attr, attr_type in six.iteritems(klass.openapi_types): + if (data is not None and + klass.attribute_map[attr] in data and + isinstance(data, (list, dict))): + value = data[klass.attribute_map[attr]] + kwargs[attr] = self.__deserialize(value, attr_type) + + instance = klass(**kwargs) + + if hasattr(instance, 'get_real_child_model'): + klass_name = instance.get_real_child_model(data) + if klass_name: + instance = self.__deserialize(data, klass_name) + return instance diff --git a/pysky_api/openapi_client/configuration.py b/pysky_api/openapi_client/configuration.py new file mode 100644 index 00000000..2d0cea62 --- /dev/null +++ b/pysky_api/openapi_client/configuration.py @@ -0,0 +1,236 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import copy +import logging +import multiprocessing +import sys +import urllib3 + +import six +from six.moves import http_client as httplib + + +class TypeWithDefault(type): + def __init__(cls, name, bases, dct): + super(TypeWithDefault, cls).__init__(name, bases, dct) + cls._default = None + + def __call__(cls): + if cls._default is None: + cls._default = type.__call__(cls) + return copy.copy(cls._default) + + def set_default(cls, default): + cls._default = copy.copy(default) + + +class Configuration(six.with_metaclass(TypeWithDefault, object)): + """NOTE: This class is auto generated by OpenAPI Generator + + Ref: https://openapi-generator.tech + Do not edit the class manually. + """ + + def __init__(self): + """Constructor""" + # Default Base url + self.host = "http://127.0.0.1:6420" + # Temp file folder for downloading files + self.temp_folder_path = None + + # Authentication Settings + # dict to store API key(s) + self.api_key = {} + # dict to store API prefix (e.g. Bearer) + self.api_key_prefix = {} + # Username for HTTP basic authentication + self.username = "" + # Password for HTTP basic authentication + self.password = "" + + # Logging Settings + self.logger = {} + self.logger["package_logger"] = logging.getLogger("openapi_client") + self.logger["urllib3_logger"] = logging.getLogger("urllib3") + # Log format + self.logger_format = '%(asctime)s %(levelname)s %(message)s' + # Log stream handler + self.logger_stream_handler = None + # Log file handler + self.logger_file_handler = None + # Debug file location + self.logger_file = None + # Debug switch + self.debug = False + + # SSL/TLS verification + # Set this to false to skip verifying SSL certificate when calling API + # from https server. + self.verify_ssl = True + # Set this to customize the certificate file to verify the peer. + self.ssl_ca_cert = None + # client certificate file + self.cert_file = None + # client key file + self.key_file = None + # Set this to True/False to enable/disable SSL hostname verification. + self.assert_hostname = None + + # urllib3 connection pool's maximum number of connections saved + # per pool. urllib3 uses 1 connection as default value, but this is + # not the best value when you are making a lot of possibly parallel + # requests to the same host, which is often the case here. + # cpu_count * 5 is used as default value to increase performance. + self.connection_pool_maxsize = multiprocessing.cpu_count() * 5 + + # Proxy URL + self.proxy = None + # Safe chars for path_param + self.safe_chars_for_path_param = '' + + @property + def logger_file(self): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + return self.__logger_file + + @logger_file.setter + def logger_file(self, value): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + self.__logger_file = value + if self.__logger_file: + # If set logging file, + # then add file handler and remove stream handler. + self.logger_file_handler = logging.FileHandler(self.__logger_file) + self.logger_file_handler.setFormatter(self.logger_formatter) + for _, logger in six.iteritems(self.logger): + logger.addHandler(self.logger_file_handler) + + @property + def debug(self): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + return self.__debug + + @debug.setter + def debug(self, value): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + self.__debug = value + if self.__debug: + # if debug status is True, turn on debug logging + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.DEBUG) + # turn on httplib debug + httplib.HTTPConnection.debuglevel = 1 + else: + # if debug status is False, turn off debug logging, + # setting log level to default `logging.WARNING` + for _, logger in six.iteritems(self.logger): + logger.setLevel(logging.WARNING) + # turn off httplib debug + httplib.HTTPConnection.debuglevel = 0 + + @property + def logger_format(self): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + return self.__logger_format + + @logger_format.setter + def logger_format(self, value): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + self.__logger_format = value + self.logger_formatter = logging.Formatter(self.__logger_format) + + def get_api_key_with_prefix(self, identifier): + """Gets API key (with prefix if set). + + :param identifier: The identifier of apiKey. + :return: The token for api key authentication. + """ + if (self.api_key.get(identifier) and + self.api_key_prefix.get(identifier)): + return self.api_key_prefix[identifier] + ' ' + self.api_key[identifier] # noqa: E501 + elif self.api_key.get(identifier): + return self.api_key[identifier] + + def get_basic_auth_token(self): + """Gets HTTP basic authentication header (string). + + :return: The token for basic HTTP authentication. + """ + return urllib3.util.make_headers( + basic_auth=self.username + ':' + self.password + ).get('authorization') + + def auth_settings(self): + """Gets Auth Settings dict for api client. + + :return: The Auth Settings information dict. + """ + return { + 'csrfAuth': + { + 'type': 'api_key', + 'in': 'header', + 'key': 'X-CSRF-TOKEN', + 'value': self.get_api_key_with_prefix('X-CSRF-TOKEN') + }, + + } + + def to_debug_report(self): + """Gets the essential information for debugging. + + :return: The report for debugging. + """ + return "Python SDK Debug Report:\n"\ + "OS: {env}\n"\ + "Python Version: {pyversion}\n"\ + "Version of the API: 0.25.1\n"\ + "SDK Package Version: 1.0.0".\ + format(env=sys.platform, pyversion=sys.version) diff --git a/pysky_api/openapi_client/models/__init__.py b/pysky_api/openapi_client/models/__init__.py new file mode 100644 index 00000000..115a689c --- /dev/null +++ b/pysky_api/openapi_client/models/__init__.py @@ -0,0 +1,38 @@ +# coding: utf-8 + +# flake8: noqa +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +# import models into model package +from openapi_client.models.apiv1exploreraddress_inputs import Apiv1exploreraddressInputs +from openapi_client.models.apiv1exploreraddress_outputs import Apiv1exploreraddressOutputs +from openapi_client.models.apiv1exploreraddress_status import Apiv1exploreraddressStatus +from openapi_client.models.apiv1pending_txs_transaction import Apiv1pendingTxsTransaction +from openapi_client.models.apiv1wallets_entries import Apiv1walletsEntries +from openapi_client.models.apiv1wallets_meta import Apiv1walletsMeta +from openapi_client.models.apiv1wallettransaction_hours_selection import Apiv1wallettransactionHoursSelection +from openapi_client.models.apiv1wallettransaction_to import Apiv1wallettransactionTo +from openapi_client.models.apiv1wallettransaction_wallet import Apiv1wallettransactionWallet +from openapi_client.models.inline_object import InlineObject +from openapi_client.models.inline_response200 import InlineResponse200 +from openapi_client.models.inline_response2001 import InlineResponse2001 +from openapi_client.models.inline_response2002 import InlineResponse2002 +from openapi_client.models.inline_response2003 import InlineResponse2003 +from openapi_client.models.inline_response2003_unconfirmed_verify_transaction import InlineResponse2003UnconfirmedVerifyTransaction +from openapi_client.models.inline_response2004 import InlineResponse2004 +from openapi_client.models.inline_response2005 import InlineResponse2005 +from openapi_client.models.inline_response2006 import InlineResponse2006 +from openapi_client.models.inline_response2007 import InlineResponse2007 +from openapi_client.models.inline_response2007_data import InlineResponse2007Data +from openapi_client.models.inline_response_default import InlineResponseDefault diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py b/pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py new file mode 100644 index 00000000..a55876a5 --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py @@ -0,0 +1,217 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1exploreraddressInputs(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'owner': 'str', + 'hours': 'int', + 'calculated_hours': 'int', + 'coins': 'str', + 'uxid': 'str' + } + + attribute_map = { + 'owner': 'owner', + 'hours': 'hours', + 'calculated_hours': 'calculated_hours', + 'coins': 'coins', + 'uxid': 'uxid' + } + + def __init__(self, owner=None, hours=None, calculated_hours=None, coins=None, uxid=None): # noqa: E501 + """Apiv1exploreraddressInputs - a model defined in OpenAPI""" # noqa: E501 + + self._owner = None + self._hours = None + self._calculated_hours = None + self._coins = None + self._uxid = None + self.discriminator = None + + if owner is not None: + self.owner = owner + if hours is not None: + self.hours = hours + if calculated_hours is not None: + self.calculated_hours = calculated_hours + if coins is not None: + self.coins = coins + if uxid is not None: + self.uxid = uxid + + @property + def owner(self): + """Gets the owner of this Apiv1exploreraddressInputs. # noqa: E501 + + + :return: The owner of this Apiv1exploreraddressInputs. # noqa: E501 + :rtype: str + """ + return self._owner + + @owner.setter + def owner(self, owner): + """Sets the owner of this Apiv1exploreraddressInputs. + + + :param owner: The owner of this Apiv1exploreraddressInputs. # noqa: E501 + :type: str + """ + + self._owner = owner + + @property + def hours(self): + """Gets the hours of this Apiv1exploreraddressInputs. # noqa: E501 + + + :return: The hours of this Apiv1exploreraddressInputs. # noqa: E501 + :rtype: int + """ + return self._hours + + @hours.setter + def hours(self, hours): + """Sets the hours of this Apiv1exploreraddressInputs. + + + :param hours: The hours of this Apiv1exploreraddressInputs. # noqa: E501 + :type: int + """ + + self._hours = hours + + @property + def calculated_hours(self): + """Gets the calculated_hours of this Apiv1exploreraddressInputs. # noqa: E501 + + + :return: The calculated_hours of this Apiv1exploreraddressInputs. # noqa: E501 + :rtype: int + """ + return self._calculated_hours + + @calculated_hours.setter + def calculated_hours(self, calculated_hours): + """Sets the calculated_hours of this Apiv1exploreraddressInputs. + + + :param calculated_hours: The calculated_hours of this Apiv1exploreraddressInputs. # noqa: E501 + :type: int + """ + + self._calculated_hours = calculated_hours + + @property + def coins(self): + """Gets the coins of this Apiv1exploreraddressInputs. # noqa: E501 + + + :return: The coins of this Apiv1exploreraddressInputs. # noqa: E501 + :rtype: str + """ + return self._coins + + @coins.setter + def coins(self, coins): + """Sets the coins of this Apiv1exploreraddressInputs. + + + :param coins: The coins of this Apiv1exploreraddressInputs. # noqa: E501 + :type: str + """ + + self._coins = coins + + @property + def uxid(self): + """Gets the uxid of this Apiv1exploreraddressInputs. # noqa: E501 + + + :return: The uxid of this Apiv1exploreraddressInputs. # noqa: E501 + :rtype: str + """ + return self._uxid + + @uxid.setter + def uxid(self, uxid): + """Sets the uxid of this Apiv1exploreraddressInputs. + + + :param uxid: The uxid of this Apiv1exploreraddressInputs. # noqa: E501 + :type: str + """ + + self._uxid = uxid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1exploreraddressInputs): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py b/pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py new file mode 100644 index 00000000..4a19991d --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py @@ -0,0 +1,191 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1exploreraddressOutputs(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'hours': 'int', + 'dst': 'str', + 'coins': 'str', + 'uxid': 'str' + } + + attribute_map = { + 'hours': 'hours', + 'dst': 'dst', + 'coins': 'coins', + 'uxid': 'uxid' + } + + def __init__(self, hours=None, dst=None, coins=None, uxid=None): # noqa: E501 + """Apiv1exploreraddressOutputs - a model defined in OpenAPI""" # noqa: E501 + + self._hours = None + self._dst = None + self._coins = None + self._uxid = None + self.discriminator = None + + if hours is not None: + self.hours = hours + if dst is not None: + self.dst = dst + if coins is not None: + self.coins = coins + if uxid is not None: + self.uxid = uxid + + @property + def hours(self): + """Gets the hours of this Apiv1exploreraddressOutputs. # noqa: E501 + + + :return: The hours of this Apiv1exploreraddressOutputs. # noqa: E501 + :rtype: int + """ + return self._hours + + @hours.setter + def hours(self, hours): + """Sets the hours of this Apiv1exploreraddressOutputs. + + + :param hours: The hours of this Apiv1exploreraddressOutputs. # noqa: E501 + :type: int + """ + + self._hours = hours + + @property + def dst(self): + """Gets the dst of this Apiv1exploreraddressOutputs. # noqa: E501 + + + :return: The dst of this Apiv1exploreraddressOutputs. # noqa: E501 + :rtype: str + """ + return self._dst + + @dst.setter + def dst(self, dst): + """Sets the dst of this Apiv1exploreraddressOutputs. + + + :param dst: The dst of this Apiv1exploreraddressOutputs. # noqa: E501 + :type: str + """ + + self._dst = dst + + @property + def coins(self): + """Gets the coins of this Apiv1exploreraddressOutputs. # noqa: E501 + + + :return: The coins of this Apiv1exploreraddressOutputs. # noqa: E501 + :rtype: str + """ + return self._coins + + @coins.setter + def coins(self, coins): + """Sets the coins of this Apiv1exploreraddressOutputs. + + + :param coins: The coins of this Apiv1exploreraddressOutputs. # noqa: E501 + :type: str + """ + + self._coins = coins + + @property + def uxid(self): + """Gets the uxid of this Apiv1exploreraddressOutputs. # noqa: E501 + + + :return: The uxid of this Apiv1exploreraddressOutputs. # noqa: E501 + :rtype: str + """ + return self._uxid + + @uxid.setter + def uxid(self, uxid): + """Sets the uxid of this Apiv1exploreraddressOutputs. + + + :param uxid: The uxid of this Apiv1exploreraddressOutputs. # noqa: E501 + :type: str + """ + + self._uxid = uxid + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1exploreraddressOutputs): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_status.py b/pysky_api/openapi_client/models/apiv1exploreraddress_status.py new file mode 100644 index 00000000..1187268f --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1exploreraddress_status.py @@ -0,0 +1,191 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1exploreraddressStatus(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'unconfirmed': 'bool', + 'block_seq': 'int', + 'label': 'int', + 'confirmed': 'bool' + } + + attribute_map = { + 'unconfirmed': 'unconfirmed', + 'block_seq': 'block_seq', + 'label': 'label', + 'confirmed': 'confirmed' + } + + def __init__(self, unconfirmed=None, block_seq=None, label=None, confirmed=None): # noqa: E501 + """Apiv1exploreraddressStatus - a model defined in OpenAPI""" # noqa: E501 + + self._unconfirmed = None + self._block_seq = None + self._label = None + self._confirmed = None + self.discriminator = None + + if unconfirmed is not None: + self.unconfirmed = unconfirmed + if block_seq is not None: + self.block_seq = block_seq + if label is not None: + self.label = label + if confirmed is not None: + self.confirmed = confirmed + + @property + def unconfirmed(self): + """Gets the unconfirmed of this Apiv1exploreraddressStatus. # noqa: E501 + + + :return: The unconfirmed of this Apiv1exploreraddressStatus. # noqa: E501 + :rtype: bool + """ + return self._unconfirmed + + @unconfirmed.setter + def unconfirmed(self, unconfirmed): + """Sets the unconfirmed of this Apiv1exploreraddressStatus. + + + :param unconfirmed: The unconfirmed of this Apiv1exploreraddressStatus. # noqa: E501 + :type: bool + """ + + self._unconfirmed = unconfirmed + + @property + def block_seq(self): + """Gets the block_seq of this Apiv1exploreraddressStatus. # noqa: E501 + + + :return: The block_seq of this Apiv1exploreraddressStatus. # noqa: E501 + :rtype: int + """ + return self._block_seq + + @block_seq.setter + def block_seq(self, block_seq): + """Sets the block_seq of this Apiv1exploreraddressStatus. + + + :param block_seq: The block_seq of this Apiv1exploreraddressStatus. # noqa: E501 + :type: int + """ + + self._block_seq = block_seq + + @property + def label(self): + """Gets the label of this Apiv1exploreraddressStatus. # noqa: E501 + + + :return: The label of this Apiv1exploreraddressStatus. # noqa: E501 + :rtype: int + """ + return self._label + + @label.setter + def label(self, label): + """Sets the label of this Apiv1exploreraddressStatus. + + + :param label: The label of this Apiv1exploreraddressStatus. # noqa: E501 + :type: int + """ + + self._label = label + + @property + def confirmed(self): + """Gets the confirmed of this Apiv1exploreraddressStatus. # noqa: E501 + + + :return: The confirmed of this Apiv1exploreraddressStatus. # noqa: E501 + :rtype: bool + """ + return self._confirmed + + @confirmed.setter + def confirmed(self, confirmed): + """Sets the confirmed of this Apiv1exploreraddressStatus. + + + :param confirmed: The confirmed of this Apiv1exploreraddressStatus. # noqa: E501 + :type: bool + """ + + self._confirmed = confirmed + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1exploreraddressStatus): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1pending_txs_transaction.py b/pysky_api/openapi_client/models/apiv1pending_txs_transaction.py new file mode 100644 index 00000000..c16692a6 --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1pending_txs_transaction.py @@ -0,0 +1,295 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1pendingTxsTransaction(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'outputs': 'list[Apiv1exploreraddressOutputs]', + 'inner_hash': 'str', + 'inputs': 'list[str]', + 'sigs': 'list[str]', + 'length': 'int', + 'txid': 'str', + 'type': 'int', + 'timestamp': 'int' + } + + attribute_map = { + 'outputs': 'outputs', + 'inner_hash': 'inner_hash', + 'inputs': 'inputs', + 'sigs': 'sigs', + 'length': 'length', + 'txid': 'txid', + 'type': 'type', + 'timestamp': 'timestamp' + } + + def __init__(self, outputs=None, inner_hash=None, inputs=None, sigs=None, length=None, txid=None, type=None, timestamp=None): # noqa: E501 + """Apiv1pendingTxsTransaction - a model defined in OpenAPI""" # noqa: E501 + + self._outputs = None + self._inner_hash = None + self._inputs = None + self._sigs = None + self._length = None + self._txid = None + self._type = None + self._timestamp = None + self.discriminator = None + + if outputs is not None: + self.outputs = outputs + if inner_hash is not None: + self.inner_hash = inner_hash + if inputs is not None: + self.inputs = inputs + if sigs is not None: + self.sigs = sigs + if length is not None: + self.length = length + if txid is not None: + self.txid = txid + if type is not None: + self.type = type + if timestamp is not None: + self.timestamp = timestamp + + @property + def outputs(self): + """Gets the outputs of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The outputs of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: list[Apiv1exploreraddressOutputs] + """ + return self._outputs + + @outputs.setter + def outputs(self, outputs): + """Sets the outputs of this Apiv1pendingTxsTransaction. + + + :param outputs: The outputs of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: list[Apiv1exploreraddressOutputs] + """ + + self._outputs = outputs + + @property + def inner_hash(self): + """Gets the inner_hash of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The inner_hash of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: str + """ + return self._inner_hash + + @inner_hash.setter + def inner_hash(self, inner_hash): + """Sets the inner_hash of this Apiv1pendingTxsTransaction. + + + :param inner_hash: The inner_hash of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: str + """ + + self._inner_hash = inner_hash + + @property + def inputs(self): + """Gets the inputs of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The inputs of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: list[str] + """ + return self._inputs + + @inputs.setter + def inputs(self, inputs): + """Sets the inputs of this Apiv1pendingTxsTransaction. + + + :param inputs: The inputs of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: list[str] + """ + + self._inputs = inputs + + @property + def sigs(self): + """Gets the sigs of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The sigs of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: list[str] + """ + return self._sigs + + @sigs.setter + def sigs(self, sigs): + """Sets the sigs of this Apiv1pendingTxsTransaction. + + + :param sigs: The sigs of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: list[str] + """ + + self._sigs = sigs + + @property + def length(self): + """Gets the length of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The length of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: int + """ + return self._length + + @length.setter + def length(self, length): + """Sets the length of this Apiv1pendingTxsTransaction. + + + :param length: The length of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: int + """ + + self._length = length + + @property + def txid(self): + """Gets the txid of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The txid of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: str + """ + return self._txid + + @txid.setter + def txid(self, txid): + """Sets the txid of this Apiv1pendingTxsTransaction. + + + :param txid: The txid of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: str + """ + + self._txid = txid + + @property + def type(self): + """Gets the type of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The type of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: int + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Apiv1pendingTxsTransaction. + + + :param type: The type of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: int + """ + + self._type = type + + @property + def timestamp(self): + """Gets the timestamp of this Apiv1pendingTxsTransaction. # noqa: E501 + + + :return: The timestamp of this Apiv1pendingTxsTransaction. # noqa: E501 + :rtype: int + """ + return self._timestamp + + @timestamp.setter + def timestamp(self, timestamp): + """Sets the timestamp of this Apiv1pendingTxsTransaction. + + + :param timestamp: The timestamp of this Apiv1pendingTxsTransaction. # noqa: E501 + :type: int + """ + + self._timestamp = timestamp + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1pendingTxsTransaction): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1wallets_entries.py b/pysky_api/openapi_client/models/apiv1wallets_entries.py new file mode 100644 index 00000000..1e178066 --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1wallets_entries.py @@ -0,0 +1,139 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1walletsEntries(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'public_key': 'str', + 'address': 'str' + } + + attribute_map = { + 'public_key': 'public_key', + 'address': 'address' + } + + def __init__(self, public_key=None, address=None): # noqa: E501 + """Apiv1walletsEntries - a model defined in OpenAPI""" # noqa: E501 + + self._public_key = None + self._address = None + self.discriminator = None + + if public_key is not None: + self.public_key = public_key + if address is not None: + self.address = address + + @property + def public_key(self): + """Gets the public_key of this Apiv1walletsEntries. # noqa: E501 + + + :return: The public_key of this Apiv1walletsEntries. # noqa: E501 + :rtype: str + """ + return self._public_key + + @public_key.setter + def public_key(self, public_key): + """Sets the public_key of this Apiv1walletsEntries. + + + :param public_key: The public_key of this Apiv1walletsEntries. # noqa: E501 + :type: str + """ + + self._public_key = public_key + + @property + def address(self): + """Gets the address of this Apiv1walletsEntries. # noqa: E501 + + + :return: The address of this Apiv1walletsEntries. # noqa: E501 + :rtype: str + """ + return self._address + + @address.setter + def address(self, address): + """Sets the address of this Apiv1walletsEntries. + + + :param address: The address of this Apiv1walletsEntries. # noqa: E501 + :type: str + """ + + self._address = address + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1walletsEntries): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1wallets_meta.py b/pysky_api/openapi_client/models/apiv1wallets_meta.py new file mode 100644 index 00000000..6fc73cfc --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1wallets_meta.py @@ -0,0 +1,295 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1walletsMeta(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'filename': 'str', + 'encrypted': 'bool', + 'crypto_type': 'str', + 'label': 'str', + 'type': 'str', + 'version': 'str', + 'coin': 'str', + 'timestamp': 'int' + } + + attribute_map = { + 'filename': 'filename', + 'encrypted': 'encrypted', + 'crypto_type': 'crypto_type', + 'label': 'label', + 'type': 'type', + 'version': 'version', + 'coin': 'coin', + 'timestamp': 'timestamp' + } + + def __init__(self, filename=None, encrypted=None, crypto_type=None, label=None, type=None, version=None, coin=None, timestamp=None): # noqa: E501 + """Apiv1walletsMeta - a model defined in OpenAPI""" # noqa: E501 + + self._filename = None + self._encrypted = None + self._crypto_type = None + self._label = None + self._type = None + self._version = None + self._coin = None + self._timestamp = None + self.discriminator = None + + if filename is not None: + self.filename = filename + if encrypted is not None: + self.encrypted = encrypted + if crypto_type is not None: + self.crypto_type = crypto_type + if label is not None: + self.label = label + if type is not None: + self.type = type + if version is not None: + self.version = version + if coin is not None: + self.coin = coin + if timestamp is not None: + self.timestamp = timestamp + + @property + def filename(self): + """Gets the filename of this Apiv1walletsMeta. # noqa: E501 + + + :return: The filename of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._filename + + @filename.setter + def filename(self, filename): + """Sets the filename of this Apiv1walletsMeta. + + + :param filename: The filename of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._filename = filename + + @property + def encrypted(self): + """Gets the encrypted of this Apiv1walletsMeta. # noqa: E501 + + + :return: The encrypted of this Apiv1walletsMeta. # noqa: E501 + :rtype: bool + """ + return self._encrypted + + @encrypted.setter + def encrypted(self, encrypted): + """Sets the encrypted of this Apiv1walletsMeta. + + + :param encrypted: The encrypted of this Apiv1walletsMeta. # noqa: E501 + :type: bool + """ + + self._encrypted = encrypted + + @property + def crypto_type(self): + """Gets the crypto_type of this Apiv1walletsMeta. # noqa: E501 + + + :return: The crypto_type of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._crypto_type + + @crypto_type.setter + def crypto_type(self, crypto_type): + """Sets the crypto_type of this Apiv1walletsMeta. + + + :param crypto_type: The crypto_type of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._crypto_type = crypto_type + + @property + def label(self): + """Gets the label of this Apiv1walletsMeta. # noqa: E501 + + + :return: The label of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._label + + @label.setter + def label(self, label): + """Sets the label of this Apiv1walletsMeta. + + + :param label: The label of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._label = label + + @property + def type(self): + """Gets the type of this Apiv1walletsMeta. # noqa: E501 + + + :return: The type of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Apiv1walletsMeta. + + + :param type: The type of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._type = type + + @property + def version(self): + """Gets the version of this Apiv1walletsMeta. # noqa: E501 + + + :return: The version of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._version + + @version.setter + def version(self, version): + """Sets the version of this Apiv1walletsMeta. + + + :param version: The version of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._version = version + + @property + def coin(self): + """Gets the coin of this Apiv1walletsMeta. # noqa: E501 + + + :return: The coin of this Apiv1walletsMeta. # noqa: E501 + :rtype: str + """ + return self._coin + + @coin.setter + def coin(self, coin): + """Sets the coin of this Apiv1walletsMeta. + + + :param coin: The coin of this Apiv1walletsMeta. # noqa: E501 + :type: str + """ + + self._coin = coin + + @property + def timestamp(self): + """Gets the timestamp of this Apiv1walletsMeta. # noqa: E501 + + + :return: The timestamp of this Apiv1walletsMeta. # noqa: E501 + :rtype: int + """ + return self._timestamp + + @timestamp.setter + def timestamp(self, timestamp): + """Sets the timestamp of this Apiv1walletsMeta. + + + :param timestamp: The timestamp of this Apiv1walletsMeta. # noqa: E501 + :type: int + """ + + self._timestamp = timestamp + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1walletsMeta): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py b/pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py new file mode 100644 index 00000000..6e7698ad --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py @@ -0,0 +1,165 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1wallettransactionHoursSelection(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'mode': 'str', + 'share_factor': 'str', + 'type': 'str' + } + + attribute_map = { + 'mode': 'mode', + 'share_factor': 'share_factor', + 'type': 'type' + } + + def __init__(self, mode=None, share_factor=None, type=None): # noqa: E501 + """Apiv1wallettransactionHoursSelection - a model defined in OpenAPI""" # noqa: E501 + + self._mode = None + self._share_factor = None + self._type = None + self.discriminator = None + + if mode is not None: + self.mode = mode + if share_factor is not None: + self.share_factor = share_factor + if type is not None: + self.type = type + + @property + def mode(self): + """Gets the mode of this Apiv1wallettransactionHoursSelection. # noqa: E501 + + + :return: The mode of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :rtype: str + """ + return self._mode + + @mode.setter + def mode(self, mode): + """Sets the mode of this Apiv1wallettransactionHoursSelection. + + + :param mode: The mode of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :type: str + """ + + self._mode = mode + + @property + def share_factor(self): + """Gets the share_factor of this Apiv1wallettransactionHoursSelection. # noqa: E501 + + + :return: The share_factor of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :rtype: str + """ + return self._share_factor + + @share_factor.setter + def share_factor(self, share_factor): + """Sets the share_factor of this Apiv1wallettransactionHoursSelection. + + + :param share_factor: The share_factor of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :type: str + """ + + self._share_factor = share_factor + + @property + def type(self): + """Gets the type of this Apiv1wallettransactionHoursSelection. # noqa: E501 + + + :return: The type of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :rtype: str + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this Apiv1wallettransactionHoursSelection. + + + :param type: The type of this Apiv1wallettransactionHoursSelection. # noqa: E501 + :type: str + """ + + self._type = type + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1wallettransactionHoursSelection): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_to.py b/pysky_api/openapi_client/models/apiv1wallettransaction_to.py new file mode 100644 index 00000000..af1d41c1 --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1wallettransaction_to.py @@ -0,0 +1,165 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1wallettransactionTo(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'hours': 'int', + 'address': 'str', + 'coins': 'int' + } + + attribute_map = { + 'hours': 'hours', + 'address': 'address', + 'coins': 'coins' + } + + def __init__(self, hours=None, address=None, coins=None): # noqa: E501 + """Apiv1wallettransactionTo - a model defined in OpenAPI""" # noqa: E501 + + self._hours = None + self._address = None + self._coins = None + self.discriminator = None + + if hours is not None: + self.hours = hours + if address is not None: + self.address = address + if coins is not None: + self.coins = coins + + @property + def hours(self): + """Gets the hours of this Apiv1wallettransactionTo. # noqa: E501 + + + :return: The hours of this Apiv1wallettransactionTo. # noqa: E501 + :rtype: int + """ + return self._hours + + @hours.setter + def hours(self, hours): + """Sets the hours of this Apiv1wallettransactionTo. + + + :param hours: The hours of this Apiv1wallettransactionTo. # noqa: E501 + :type: int + """ + + self._hours = hours + + @property + def address(self): + """Gets the address of this Apiv1wallettransactionTo. # noqa: E501 + + + :return: The address of this Apiv1wallettransactionTo. # noqa: E501 + :rtype: str + """ + return self._address + + @address.setter + def address(self, address): + """Sets the address of this Apiv1wallettransactionTo. + + + :param address: The address of this Apiv1wallettransactionTo. # noqa: E501 + :type: str + """ + + self._address = address + + @property + def coins(self): + """Gets the coins of this Apiv1wallettransactionTo. # noqa: E501 + + + :return: The coins of this Apiv1wallettransactionTo. # noqa: E501 + :rtype: int + """ + return self._coins + + @coins.setter + def coins(self, coins): + """Sets the coins of this Apiv1wallettransactionTo. + + + :param coins: The coins of this Apiv1wallettransactionTo. # noqa: E501 + :type: int + """ + + self._coins = coins + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1wallettransactionTo): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py b/pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py new file mode 100644 index 00000000..6d81726f --- /dev/null +++ b/pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py @@ -0,0 +1,191 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class Apiv1wallettransactionWallet(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'unspents': 'list[str]', + 'addresses': 'list[str]', + 'password': 'str', + 'id': 'str' + } + + attribute_map = { + 'unspents': 'unspents', + 'addresses': 'addresses', + 'password': 'password', + 'id': 'id' + } + + def __init__(self, unspents=None, addresses=None, password=None, id=None): # noqa: E501 + """Apiv1wallettransactionWallet - a model defined in OpenAPI""" # noqa: E501 + + self._unspents = None + self._addresses = None + self._password = None + self._id = None + self.discriminator = None + + if unspents is not None: + self.unspents = unspents + if addresses is not None: + self.addresses = addresses + if password is not None: + self.password = password + if id is not None: + self.id = id + + @property + def unspents(self): + """Gets the unspents of this Apiv1wallettransactionWallet. # noqa: E501 + + + :return: The unspents of this Apiv1wallettransactionWallet. # noqa: E501 + :rtype: list[str] + """ + return self._unspents + + @unspents.setter + def unspents(self, unspents): + """Sets the unspents of this Apiv1wallettransactionWallet. + + + :param unspents: The unspents of this Apiv1wallettransactionWallet. # noqa: E501 + :type: list[str] + """ + + self._unspents = unspents + + @property + def addresses(self): + """Gets the addresses of this Apiv1wallettransactionWallet. # noqa: E501 + + + :return: The addresses of this Apiv1wallettransactionWallet. # noqa: E501 + :rtype: list[str] + """ + return self._addresses + + @addresses.setter + def addresses(self, addresses): + """Sets the addresses of this Apiv1wallettransactionWallet. + + + :param addresses: The addresses of this Apiv1wallettransactionWallet. # noqa: E501 + :type: list[str] + """ + + self._addresses = addresses + + @property + def password(self): + """Gets the password of this Apiv1wallettransactionWallet. # noqa: E501 + + + :return: The password of this Apiv1wallettransactionWallet. # noqa: E501 + :rtype: str + """ + return self._password + + @password.setter + def password(self, password): + """Sets the password of this Apiv1wallettransactionWallet. + + + :param password: The password of this Apiv1wallettransactionWallet. # noqa: E501 + :type: str + """ + + self._password = password + + @property + def id(self): + """Gets the id of this Apiv1wallettransactionWallet. # noqa: E501 + + + :return: The id of this Apiv1wallettransactionWallet. # noqa: E501 + :rtype: str + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this Apiv1wallettransactionWallet. + + + :param id: The id of this Apiv1wallettransactionWallet. # noqa: E501 + :type: str + """ + + self._id = id + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, Apiv1wallettransactionWallet): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_object.py b/pysky_api/openapi_client/models/inline_object.py new file mode 100644 index 00000000..ae66dab0 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_object.py @@ -0,0 +1,217 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineObject(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'change_address': 'str', + 'hours_selection': 'Apiv1wallettransactionHoursSelection', + 'ignore_unconfirmed': 'bool', + 'to': 'list[Apiv1wallettransactionTo]', + 'wallet': 'Apiv1wallettransactionWallet' + } + + attribute_map = { + 'change_address': 'change_address', + 'hours_selection': 'hours_selection', + 'ignore_unconfirmed': 'ignore_unconfirmed', + 'to': 'to', + 'wallet': 'wallet' + } + + def __init__(self, change_address=None, hours_selection=None, ignore_unconfirmed=None, to=None, wallet=None): # noqa: E501 + """InlineObject - a model defined in OpenAPI""" # noqa: E501 + + self._change_address = None + self._hours_selection = None + self._ignore_unconfirmed = None + self._to = None + self._wallet = None + self.discriminator = None + + if change_address is not None: + self.change_address = change_address + if hours_selection is not None: + self.hours_selection = hours_selection + if ignore_unconfirmed is not None: + self.ignore_unconfirmed = ignore_unconfirmed + if to is not None: + self.to = to + if wallet is not None: + self.wallet = wallet + + @property + def change_address(self): + """Gets the change_address of this InlineObject. # noqa: E501 + + + :return: The change_address of this InlineObject. # noqa: E501 + :rtype: str + """ + return self._change_address + + @change_address.setter + def change_address(self, change_address): + """Sets the change_address of this InlineObject. + + + :param change_address: The change_address of this InlineObject. # noqa: E501 + :type: str + """ + + self._change_address = change_address + + @property + def hours_selection(self): + """Gets the hours_selection of this InlineObject. # noqa: E501 + + + :return: The hours_selection of this InlineObject. # noqa: E501 + :rtype: Apiv1wallettransactionHoursSelection + """ + return self._hours_selection + + @hours_selection.setter + def hours_selection(self, hours_selection): + """Sets the hours_selection of this InlineObject. + + + :param hours_selection: The hours_selection of this InlineObject. # noqa: E501 + :type: Apiv1wallettransactionHoursSelection + """ + + self._hours_selection = hours_selection + + @property + def ignore_unconfirmed(self): + """Gets the ignore_unconfirmed of this InlineObject. # noqa: E501 + + + :return: The ignore_unconfirmed of this InlineObject. # noqa: E501 + :rtype: bool + """ + return self._ignore_unconfirmed + + @ignore_unconfirmed.setter + def ignore_unconfirmed(self, ignore_unconfirmed): + """Sets the ignore_unconfirmed of this InlineObject. + + + :param ignore_unconfirmed: The ignore_unconfirmed of this InlineObject. # noqa: E501 + :type: bool + """ + + self._ignore_unconfirmed = ignore_unconfirmed + + @property + def to(self): + """Gets the to of this InlineObject. # noqa: E501 + + + :return: The to of this InlineObject. # noqa: E501 + :rtype: list[Apiv1wallettransactionTo] + """ + return self._to + + @to.setter + def to(self, to): + """Sets the to of this InlineObject. + + + :param to: The to of this InlineObject. # noqa: E501 + :type: list[Apiv1wallettransactionTo] + """ + + self._to = to + + @property + def wallet(self): + """Gets the wallet of this InlineObject. # noqa: E501 + + + :return: The wallet of this InlineObject. # noqa: E501 + :rtype: Apiv1wallettransactionWallet + """ + return self._wallet + + @wallet.setter + def wallet(self, wallet): + """Sets the wallet of this InlineObject. + + + :param wallet: The wallet of this InlineObject. # noqa: E501 + :type: Apiv1wallettransactionWallet + """ + + self._wallet = wallet + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineObject): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response200.py b/pysky_api/openapi_client/models/inline_response200.py new file mode 100644 index 00000000..3e294c4c --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response200.py @@ -0,0 +1,321 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse200(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'hours': 'int', + 'coins': 'int', + 'uxid': 'str', + 'owner_address': 'str', + 'spent_block_seq': 'int', + 'spent_tx': 'str', + 'time': 'int', + 'src_block_seq': 'int', + 'src_tx': 'str' + } + + attribute_map = { + 'hours': 'hours', + 'coins': 'coins', + 'uxid': 'uxid', + 'owner_address': 'owner_address', + 'spent_block_seq': 'spent_block_seq', + 'spent_tx': 'spent_tx', + 'time': 'time', + 'src_block_seq': 'src_block_seq', + 'src_tx': 'src_tx' + } + + def __init__(self, hours=None, coins=None, uxid=None, owner_address=None, spent_block_seq=None, spent_tx=None, time=None, src_block_seq=None, src_tx=None): # noqa: E501 + """InlineResponse200 - a model defined in OpenAPI""" # noqa: E501 + + self._hours = None + self._coins = None + self._uxid = None + self._owner_address = None + self._spent_block_seq = None + self._spent_tx = None + self._time = None + self._src_block_seq = None + self._src_tx = None + self.discriminator = None + + if hours is not None: + self.hours = hours + if coins is not None: + self.coins = coins + if uxid is not None: + self.uxid = uxid + if owner_address is not None: + self.owner_address = owner_address + if spent_block_seq is not None: + self.spent_block_seq = spent_block_seq + if spent_tx is not None: + self.spent_tx = spent_tx + if time is not None: + self.time = time + if src_block_seq is not None: + self.src_block_seq = src_block_seq + if src_tx is not None: + self.src_tx = src_tx + + @property + def hours(self): + """Gets the hours of this InlineResponse200. # noqa: E501 + + + :return: The hours of this InlineResponse200. # noqa: E501 + :rtype: int + """ + return self._hours + + @hours.setter + def hours(self, hours): + """Sets the hours of this InlineResponse200. + + + :param hours: The hours of this InlineResponse200. # noqa: E501 + :type: int + """ + + self._hours = hours + + @property + def coins(self): + """Gets the coins of this InlineResponse200. # noqa: E501 + + + :return: The coins of this InlineResponse200. # noqa: E501 + :rtype: int + """ + return self._coins + + @coins.setter + def coins(self, coins): + """Sets the coins of this InlineResponse200. + + + :param coins: The coins of this InlineResponse200. # noqa: E501 + :type: int + """ + + self._coins = coins + + @property + def uxid(self): + """Gets the uxid of this InlineResponse200. # noqa: E501 + + + :return: The uxid of this InlineResponse200. # noqa: E501 + :rtype: str + """ + return self._uxid + + @uxid.setter + def uxid(self, uxid): + """Sets the uxid of this InlineResponse200. + + + :param uxid: The uxid of this InlineResponse200. # noqa: E501 + :type: str + """ + + self._uxid = uxid + + @property + def owner_address(self): + """Gets the owner_address of this InlineResponse200. # noqa: E501 + + + :return: The owner_address of this InlineResponse200. # noqa: E501 + :rtype: str + """ + return self._owner_address + + @owner_address.setter + def owner_address(self, owner_address): + """Sets the owner_address of this InlineResponse200. + + + :param owner_address: The owner_address of this InlineResponse200. # noqa: E501 + :type: str + """ + + self._owner_address = owner_address + + @property + def spent_block_seq(self): + """Gets the spent_block_seq of this InlineResponse200. # noqa: E501 + + + :return: The spent_block_seq of this InlineResponse200. # noqa: E501 + :rtype: int + """ + return self._spent_block_seq + + @spent_block_seq.setter + def spent_block_seq(self, spent_block_seq): + """Sets the spent_block_seq of this InlineResponse200. + + + :param spent_block_seq: The spent_block_seq of this InlineResponse200. # noqa: E501 + :type: int + """ + + self._spent_block_seq = spent_block_seq + + @property + def spent_tx(self): + """Gets the spent_tx of this InlineResponse200. # noqa: E501 + + + :return: The spent_tx of this InlineResponse200. # noqa: E501 + :rtype: str + """ + return self._spent_tx + + @spent_tx.setter + def spent_tx(self, spent_tx): + """Sets the spent_tx of this InlineResponse200. + + + :param spent_tx: The spent_tx of this InlineResponse200. # noqa: E501 + :type: str + """ + + self._spent_tx = spent_tx + + @property + def time(self): + """Gets the time of this InlineResponse200. # noqa: E501 + + + :return: The time of this InlineResponse200. # noqa: E501 + :rtype: int + """ + return self._time + + @time.setter + def time(self, time): + """Sets the time of this InlineResponse200. + + + :param time: The time of this InlineResponse200. # noqa: E501 + :type: int + """ + + self._time = time + + @property + def src_block_seq(self): + """Gets the src_block_seq of this InlineResponse200. # noqa: E501 + + + :return: The src_block_seq of this InlineResponse200. # noqa: E501 + :rtype: int + """ + return self._src_block_seq + + @src_block_seq.setter + def src_block_seq(self, src_block_seq): + """Sets the src_block_seq of this InlineResponse200. + + + :param src_block_seq: The src_block_seq of this InlineResponse200. # noqa: E501 + :type: int + """ + + self._src_block_seq = src_block_seq + + @property + def src_tx(self): + """Gets the src_tx of this InlineResponse200. # noqa: E501 + + + :return: The src_tx of this InlineResponse200. # noqa: E501 + :rtype: str + """ + return self._src_tx + + @src_tx.setter + def src_tx(self, src_tx): + """Sets the src_tx of this InlineResponse200. + + + :param src_tx: The src_tx of this InlineResponse200. # noqa: E501 + :type: str + """ + + self._src_tx = src_tx + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse200): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2001.py b/pysky_api/openapi_client/models/inline_response2001.py new file mode 100644 index 00000000..dd4d1b47 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2001.py @@ -0,0 +1,113 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2001(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'csrf_token': 'str' + } + + attribute_map = { + 'csrf_token': 'csrf_token' + } + + def __init__(self, csrf_token=None): # noqa: E501 + """InlineResponse2001 - a model defined in OpenAPI""" # noqa: E501 + + self._csrf_token = None + self.discriminator = None + + if csrf_token is not None: + self.csrf_token = csrf_token + + @property + def csrf_token(self): + """Gets the csrf_token of this InlineResponse2001. # noqa: E501 + + + :return: The csrf_token of this InlineResponse2001. # noqa: E501 + :rtype: str + """ + return self._csrf_token + + @csrf_token.setter + def csrf_token(self, csrf_token): + """Sets the csrf_token of this InlineResponse2001. + + + :param csrf_token: The csrf_token of this InlineResponse2001. # noqa: E501 + :type: str + """ + + self._csrf_token = csrf_token + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2001): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2002.py b/pysky_api/openapi_client/models/inline_response2002.py new file mode 100644 index 00000000..914c5c58 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2002.py @@ -0,0 +1,347 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2002(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'outputs': 'list[Apiv1exploreraddressOutputs]', + 'inner_hash': 'str', + 'inputs': 'list[Apiv1exploreraddressInputs]', + 'fee': 'int', + 'sigs': 'list[str]', + 'length': 'int', + 'txid': 'str', + 'type': 'int', + 'status': 'Apiv1exploreraddressStatus', + 'timestamp': 'int' + } + + attribute_map = { + 'outputs': 'outputs', + 'inner_hash': 'inner_hash', + 'inputs': 'inputs', + 'fee': 'fee', + 'sigs': 'sigs', + 'length': 'length', + 'txid': 'txid', + 'type': 'type', + 'status': 'status', + 'timestamp': 'timestamp' + } + + def __init__(self, outputs=None, inner_hash=None, inputs=None, fee=None, sigs=None, length=None, txid=None, type=None, status=None, timestamp=None): # noqa: E501 + """InlineResponse2002 - a model defined in OpenAPI""" # noqa: E501 + + self._outputs = None + self._inner_hash = None + self._inputs = None + self._fee = None + self._sigs = None + self._length = None + self._txid = None + self._type = None + self._status = None + self._timestamp = None + self.discriminator = None + + if outputs is not None: + self.outputs = outputs + if inner_hash is not None: + self.inner_hash = inner_hash + if inputs is not None: + self.inputs = inputs + if fee is not None: + self.fee = fee + if sigs is not None: + self.sigs = sigs + if length is not None: + self.length = length + if txid is not None: + self.txid = txid + if type is not None: + self.type = type + if status is not None: + self.status = status + if timestamp is not None: + self.timestamp = timestamp + + @property + def outputs(self): + """Gets the outputs of this InlineResponse2002. # noqa: E501 + + + :return: The outputs of this InlineResponse2002. # noqa: E501 + :rtype: list[Apiv1exploreraddressOutputs] + """ + return self._outputs + + @outputs.setter + def outputs(self, outputs): + """Sets the outputs of this InlineResponse2002. + + + :param outputs: The outputs of this InlineResponse2002. # noqa: E501 + :type: list[Apiv1exploreraddressOutputs] + """ + + self._outputs = outputs + + @property + def inner_hash(self): + """Gets the inner_hash of this InlineResponse2002. # noqa: E501 + + + :return: The inner_hash of this InlineResponse2002. # noqa: E501 + :rtype: str + """ + return self._inner_hash + + @inner_hash.setter + def inner_hash(self, inner_hash): + """Sets the inner_hash of this InlineResponse2002. + + + :param inner_hash: The inner_hash of this InlineResponse2002. # noqa: E501 + :type: str + """ + + self._inner_hash = inner_hash + + @property + def inputs(self): + """Gets the inputs of this InlineResponse2002. # noqa: E501 + + + :return: The inputs of this InlineResponse2002. # noqa: E501 + :rtype: list[Apiv1exploreraddressInputs] + """ + return self._inputs + + @inputs.setter + def inputs(self, inputs): + """Sets the inputs of this InlineResponse2002. + + + :param inputs: The inputs of this InlineResponse2002. # noqa: E501 + :type: list[Apiv1exploreraddressInputs] + """ + + self._inputs = inputs + + @property + def fee(self): + """Gets the fee of this InlineResponse2002. # noqa: E501 + + + :return: The fee of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._fee + + @fee.setter + def fee(self, fee): + """Sets the fee of this InlineResponse2002. + + + :param fee: The fee of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._fee = fee + + @property + def sigs(self): + """Gets the sigs of this InlineResponse2002. # noqa: E501 + + + :return: The sigs of this InlineResponse2002. # noqa: E501 + :rtype: list[str] + """ + return self._sigs + + @sigs.setter + def sigs(self, sigs): + """Sets the sigs of this InlineResponse2002. + + + :param sigs: The sigs of this InlineResponse2002. # noqa: E501 + :type: list[str] + """ + + self._sigs = sigs + + @property + def length(self): + """Gets the length of this InlineResponse2002. # noqa: E501 + + + :return: The length of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._length + + @length.setter + def length(self, length): + """Sets the length of this InlineResponse2002. + + + :param length: The length of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._length = length + + @property + def txid(self): + """Gets the txid of this InlineResponse2002. # noqa: E501 + + + :return: The txid of this InlineResponse2002. # noqa: E501 + :rtype: str + """ + return self._txid + + @txid.setter + def txid(self, txid): + """Sets the txid of this InlineResponse2002. + + + :param txid: The txid of this InlineResponse2002. # noqa: E501 + :type: str + """ + + self._txid = txid + + @property + def type(self): + """Gets the type of this InlineResponse2002. # noqa: E501 + + + :return: The type of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._type + + @type.setter + def type(self, type): + """Sets the type of this InlineResponse2002. + + + :param type: The type of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._type = type + + @property + def status(self): + """Gets the status of this InlineResponse2002. # noqa: E501 + + + :return: The status of this InlineResponse2002. # noqa: E501 + :rtype: Apiv1exploreraddressStatus + """ + return self._status + + @status.setter + def status(self, status): + """Sets the status of this InlineResponse2002. + + + :param status: The status of this InlineResponse2002. # noqa: E501 + :type: Apiv1exploreraddressStatus + """ + + self._status = status + + @property + def timestamp(self): + """Gets the timestamp of this InlineResponse2002. # noqa: E501 + + + :return: The timestamp of this InlineResponse2002. # noqa: E501 + :rtype: int + """ + return self._timestamp + + @timestamp.setter + def timestamp(self, timestamp): + """Sets the timestamp of this InlineResponse2002. + + + :param timestamp: The timestamp of this InlineResponse2002. # noqa: E501 + :type: int + """ + + self._timestamp = timestamp + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2002): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2003.py b/pysky_api/openapi_client/models/inline_response2003.py new file mode 100644 index 00000000..434d1126 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2003.py @@ -0,0 +1,431 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2003(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'last_received': 'int', + 'last_sent': 'int', + 'outgoing': 'bool', + 'mirror': 'int', + 'address': 'str', + 'listen_port': 'int', + 'is_trusted_peer': 'bool', + 'connected_at': 'int', + 'unconfirmed_verify_transaction': 'InlineResponse2003UnconfirmedVerifyTransaction', + 'id': 'int', + 'state': 'str', + 'user_agent': 'str', + 'height': 'int' + } + + attribute_map = { + 'last_received': 'last_received', + 'last_sent': 'last_sent', + 'outgoing': 'outgoing', + 'mirror': 'mirror', + 'address': 'address', + 'listen_port': 'listen_port', + 'is_trusted_peer': 'is_trusted_peer', + 'connected_at': 'connected_at', + 'unconfirmed_verify_transaction': 'unconfirmed_verify_transaction', + 'id': 'id', + 'state': 'state', + 'user_agent': 'user_agent', + 'height': 'height' + } + + def __init__(self, last_received=None, last_sent=None, outgoing=None, mirror=None, address=None, listen_port=None, is_trusted_peer=None, connected_at=None, unconfirmed_verify_transaction=None, id=None, state=None, user_agent=None, height=None): # noqa: E501 + """InlineResponse2003 - a model defined in OpenAPI""" # noqa: E501 + + self._last_received = None + self._last_sent = None + self._outgoing = None + self._mirror = None + self._address = None + self._listen_port = None + self._is_trusted_peer = None + self._connected_at = None + self._unconfirmed_verify_transaction = None + self._id = None + self._state = None + self._user_agent = None + self._height = None + self.discriminator = None + + if last_received is not None: + self.last_received = last_received + if last_sent is not None: + self.last_sent = last_sent + if outgoing is not None: + self.outgoing = outgoing + if mirror is not None: + self.mirror = mirror + if address is not None: + self.address = address + if listen_port is not None: + self.listen_port = listen_port + if is_trusted_peer is not None: + self.is_trusted_peer = is_trusted_peer + if connected_at is not None: + self.connected_at = connected_at + if unconfirmed_verify_transaction is not None: + self.unconfirmed_verify_transaction = unconfirmed_verify_transaction + if id is not None: + self.id = id + if state is not None: + self.state = state + if user_agent is not None: + self.user_agent = user_agent + if height is not None: + self.height = height + + @property + def last_received(self): + """Gets the last_received of this InlineResponse2003. # noqa: E501 + + + :return: The last_received of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._last_received + + @last_received.setter + def last_received(self, last_received): + """Sets the last_received of this InlineResponse2003. + + + :param last_received: The last_received of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._last_received = last_received + + @property + def last_sent(self): + """Gets the last_sent of this InlineResponse2003. # noqa: E501 + + + :return: The last_sent of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._last_sent + + @last_sent.setter + def last_sent(self, last_sent): + """Sets the last_sent of this InlineResponse2003. + + + :param last_sent: The last_sent of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._last_sent = last_sent + + @property + def outgoing(self): + """Gets the outgoing of this InlineResponse2003. # noqa: E501 + + + :return: The outgoing of this InlineResponse2003. # noqa: E501 + :rtype: bool + """ + return self._outgoing + + @outgoing.setter + def outgoing(self, outgoing): + """Sets the outgoing of this InlineResponse2003. + + + :param outgoing: The outgoing of this InlineResponse2003. # noqa: E501 + :type: bool + """ + + self._outgoing = outgoing + + @property + def mirror(self): + """Gets the mirror of this InlineResponse2003. # noqa: E501 + + + :return: The mirror of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._mirror + + @mirror.setter + def mirror(self, mirror): + """Sets the mirror of this InlineResponse2003. + + + :param mirror: The mirror of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._mirror = mirror + + @property + def address(self): + """Gets the address of this InlineResponse2003. # noqa: E501 + + + :return: The address of this InlineResponse2003. # noqa: E501 + :rtype: str + """ + return self._address + + @address.setter + def address(self, address): + """Sets the address of this InlineResponse2003. + + + :param address: The address of this InlineResponse2003. # noqa: E501 + :type: str + """ + + self._address = address + + @property + def listen_port(self): + """Gets the listen_port of this InlineResponse2003. # noqa: E501 + + + :return: The listen_port of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._listen_port + + @listen_port.setter + def listen_port(self, listen_port): + """Sets the listen_port of this InlineResponse2003. + + + :param listen_port: The listen_port of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._listen_port = listen_port + + @property + def is_trusted_peer(self): + """Gets the is_trusted_peer of this InlineResponse2003. # noqa: E501 + + + :return: The is_trusted_peer of this InlineResponse2003. # noqa: E501 + :rtype: bool + """ + return self._is_trusted_peer + + @is_trusted_peer.setter + def is_trusted_peer(self, is_trusted_peer): + """Sets the is_trusted_peer of this InlineResponse2003. + + + :param is_trusted_peer: The is_trusted_peer of this InlineResponse2003. # noqa: E501 + :type: bool + """ + + self._is_trusted_peer = is_trusted_peer + + @property + def connected_at(self): + """Gets the connected_at of this InlineResponse2003. # noqa: E501 + + + :return: The connected_at of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._connected_at + + @connected_at.setter + def connected_at(self, connected_at): + """Sets the connected_at of this InlineResponse2003. + + + :param connected_at: The connected_at of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._connected_at = connected_at + + @property + def unconfirmed_verify_transaction(self): + """Gets the unconfirmed_verify_transaction of this InlineResponse2003. # noqa: E501 + + + :return: The unconfirmed_verify_transaction of this InlineResponse2003. # noqa: E501 + :rtype: InlineResponse2003UnconfirmedVerifyTransaction + """ + return self._unconfirmed_verify_transaction + + @unconfirmed_verify_transaction.setter + def unconfirmed_verify_transaction(self, unconfirmed_verify_transaction): + """Sets the unconfirmed_verify_transaction of this InlineResponse2003. + + + :param unconfirmed_verify_transaction: The unconfirmed_verify_transaction of this InlineResponse2003. # noqa: E501 + :type: InlineResponse2003UnconfirmedVerifyTransaction + """ + + self._unconfirmed_verify_transaction = unconfirmed_verify_transaction + + @property + def id(self): + """Gets the id of this InlineResponse2003. # noqa: E501 + + + :return: The id of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._id + + @id.setter + def id(self, id): + """Sets the id of this InlineResponse2003. + + + :param id: The id of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._id = id + + @property + def state(self): + """Gets the state of this InlineResponse2003. # noqa: E501 + + + :return: The state of this InlineResponse2003. # noqa: E501 + :rtype: str + """ + return self._state + + @state.setter + def state(self, state): + """Sets the state of this InlineResponse2003. + + + :param state: The state of this InlineResponse2003. # noqa: E501 + :type: str + """ + allowed_values = ["pending", "connected", "introduced"] # noqa: E501 + if state not in allowed_values: + raise ValueError( + "Invalid value for `state` ({0}), must be one of {1}" # noqa: E501 + .format(state, allowed_values) + ) + + self._state = state + + @property + def user_agent(self): + """Gets the user_agent of this InlineResponse2003. # noqa: E501 + + + :return: The user_agent of this InlineResponse2003. # noqa: E501 + :rtype: str + """ + return self._user_agent + + @user_agent.setter + def user_agent(self, user_agent): + """Sets the user_agent of this InlineResponse2003. + + + :param user_agent: The user_agent of this InlineResponse2003. # noqa: E501 + :type: str + """ + + self._user_agent = user_agent + + @property + def height(self): + """Gets the height of this InlineResponse2003. # noqa: E501 + + + :return: The height of this InlineResponse2003. # noqa: E501 + :rtype: int + """ + return self._height + + @height.setter + def height(self, height): + """Sets the height of this InlineResponse2003. + + + :param height: The height of this InlineResponse2003. # noqa: E501 + :type: int + """ + + self._height = height + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2003): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py b/pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py new file mode 100644 index 00000000..a162a8b5 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py @@ -0,0 +1,165 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2003UnconfirmedVerifyTransaction(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'burn_factor': 'int', + 'max_transaction_size': 'int', + 'max_decimals': 'int' + } + + attribute_map = { + 'burn_factor': 'burn_factor', + 'max_transaction_size': 'max_transaction_size', + 'max_decimals': 'max_decimals' + } + + def __init__(self, burn_factor=None, max_transaction_size=None, max_decimals=None): # noqa: E501 + """InlineResponse2003UnconfirmedVerifyTransaction - a model defined in OpenAPI""" # noqa: E501 + + self._burn_factor = None + self._max_transaction_size = None + self._max_decimals = None + self.discriminator = None + + if burn_factor is not None: + self.burn_factor = burn_factor + if max_transaction_size is not None: + self.max_transaction_size = max_transaction_size + if max_decimals is not None: + self.max_decimals = max_decimals + + @property + def burn_factor(self): + """Gets the burn_factor of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + + + :return: The burn_factor of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :rtype: int + """ + return self._burn_factor + + @burn_factor.setter + def burn_factor(self, burn_factor): + """Sets the burn_factor of this InlineResponse2003UnconfirmedVerifyTransaction. + + + :param burn_factor: The burn_factor of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :type: int + """ + + self._burn_factor = burn_factor + + @property + def max_transaction_size(self): + """Gets the max_transaction_size of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + + + :return: The max_transaction_size of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :rtype: int + """ + return self._max_transaction_size + + @max_transaction_size.setter + def max_transaction_size(self, max_transaction_size): + """Sets the max_transaction_size of this InlineResponse2003UnconfirmedVerifyTransaction. + + + :param max_transaction_size: The max_transaction_size of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :type: int + """ + + self._max_transaction_size = max_transaction_size + + @property + def max_decimals(self): + """Gets the max_decimals of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + + + :return: The max_decimals of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :rtype: int + """ + return self._max_decimals + + @max_decimals.setter + def max_decimals(self, max_decimals): + """Sets the max_decimals of this InlineResponse2003UnconfirmedVerifyTransaction. + + + :param max_decimals: The max_decimals of this InlineResponse2003UnconfirmedVerifyTransaction. # noqa: E501 + :type: int + """ + + self._max_decimals = max_decimals + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2003UnconfirmedVerifyTransaction): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2004.py b/pysky_api/openapi_client/models/inline_response2004.py new file mode 100644 index 00000000..ea6527a6 --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2004.py @@ -0,0 +1,217 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2004(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'announced': 'str', + 'is_valid': 'bool', + 'checked': 'str', + 'received': 'str', + 'transaction': 'Apiv1pendingTxsTransaction' + } + + attribute_map = { + 'announced': 'announced', + 'is_valid': 'is_valid', + 'checked': 'checked', + 'received': 'received', + 'transaction': 'transaction' + } + + def __init__(self, announced=None, is_valid=None, checked=None, received=None, transaction=None): # noqa: E501 + """InlineResponse2004 - a model defined in OpenAPI""" # noqa: E501 + + self._announced = None + self._is_valid = None + self._checked = None + self._received = None + self._transaction = None + self.discriminator = None + + if announced is not None: + self.announced = announced + if is_valid is not None: + self.is_valid = is_valid + if checked is not None: + self.checked = checked + if received is not None: + self.received = received + if transaction is not None: + self.transaction = transaction + + @property + def announced(self): + """Gets the announced of this InlineResponse2004. # noqa: E501 + + + :return: The announced of this InlineResponse2004. # noqa: E501 + :rtype: str + """ + return self._announced + + @announced.setter + def announced(self, announced): + """Sets the announced of this InlineResponse2004. + + + :param announced: The announced of this InlineResponse2004. # noqa: E501 + :type: str + """ + + self._announced = announced + + @property + def is_valid(self): + """Gets the is_valid of this InlineResponse2004. # noqa: E501 + + + :return: The is_valid of this InlineResponse2004. # noqa: E501 + :rtype: bool + """ + return self._is_valid + + @is_valid.setter + def is_valid(self, is_valid): + """Sets the is_valid of this InlineResponse2004. + + + :param is_valid: The is_valid of this InlineResponse2004. # noqa: E501 + :type: bool + """ + + self._is_valid = is_valid + + @property + def checked(self): + """Gets the checked of this InlineResponse2004. # noqa: E501 + + + :return: The checked of this InlineResponse2004. # noqa: E501 + :rtype: str + """ + return self._checked + + @checked.setter + def checked(self, checked): + """Sets the checked of this InlineResponse2004. + + + :param checked: The checked of this InlineResponse2004. # noqa: E501 + :type: str + """ + + self._checked = checked + + @property + def received(self): + """Gets the received of this InlineResponse2004. # noqa: E501 + + + :return: The received of this InlineResponse2004. # noqa: E501 + :rtype: str + """ + return self._received + + @received.setter + def received(self, received): + """Sets the received of this InlineResponse2004. + + + :param received: The received of this InlineResponse2004. # noqa: E501 + :type: str + """ + + self._received = received + + @property + def transaction(self): + """Gets the transaction of this InlineResponse2004. # noqa: E501 + + + :return: The transaction of this InlineResponse2004. # noqa: E501 + :rtype: Apiv1pendingTxsTransaction + """ + return self._transaction + + @transaction.setter + def transaction(self, transaction): + """Sets the transaction of this InlineResponse2004. + + + :param transaction: The transaction of this InlineResponse2004. # noqa: E501 + :type: Apiv1pendingTxsTransaction + """ + + self._transaction = transaction + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2004): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2005.py b/pysky_api/openapi_client/models/inline_response2005.py new file mode 100644 index 00000000..560a2fed --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2005.py @@ -0,0 +1,139 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2005(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'entries': 'list[Apiv1walletsEntries]', + 'meta': 'Apiv1walletsMeta' + } + + attribute_map = { + 'entries': 'entries', + 'meta': 'meta' + } + + def __init__(self, entries=None, meta=None): # noqa: E501 + """InlineResponse2005 - a model defined in OpenAPI""" # noqa: E501 + + self._entries = None + self._meta = None + self.discriminator = None + + if entries is not None: + self.entries = entries + if meta is not None: + self.meta = meta + + @property + def entries(self): + """Gets the entries of this InlineResponse2005. # noqa: E501 + + + :return: The entries of this InlineResponse2005. # noqa: E501 + :rtype: list[Apiv1walletsEntries] + """ + return self._entries + + @entries.setter + def entries(self, entries): + """Sets the entries of this InlineResponse2005. + + + :param entries: The entries of this InlineResponse2005. # noqa: E501 + :type: list[Apiv1walletsEntries] + """ + + self._entries = entries + + @property + def meta(self): + """Gets the meta of this InlineResponse2005. # noqa: E501 + + + :return: The meta of this InlineResponse2005. # noqa: E501 + :rtype: Apiv1walletsMeta + """ + return self._meta + + @meta.setter + def meta(self, meta): + """Sets the meta of this InlineResponse2005. + + + :param meta: The meta of this InlineResponse2005. # noqa: E501 + :type: Apiv1walletsMeta + """ + + self._meta = meta + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2005): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2006.py b/pysky_api/openapi_client/models/inline_response2006.py new file mode 100644 index 00000000..7018aedb --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2006.py @@ -0,0 +1,113 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2006(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'address': 'str' + } + + attribute_map = { + 'address': 'address' + } + + def __init__(self, address=None): # noqa: E501 + """InlineResponse2006 - a model defined in OpenAPI""" # noqa: E501 + + self._address = None + self.discriminator = None + + if address is not None: + self.address = address + + @property + def address(self): + """Gets the address of this InlineResponse2006. # noqa: E501 + + + :return: The address of this InlineResponse2006. # noqa: E501 + :rtype: str + """ + return self._address + + @address.setter + def address(self, address): + """Sets the address of this InlineResponse2006. + + + :param address: The address of this InlineResponse2006. # noqa: E501 + :type: str + """ + + self._address = address + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2006): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2007.py b/pysky_api/openapi_client/models/inline_response2007.py new file mode 100644 index 00000000..af612e0a --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2007.py @@ -0,0 +1,139 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2007(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'data': 'InlineResponse2007Data', + 'error': 'object' + } + + attribute_map = { + 'data': 'data', + 'error': 'error' + } + + def __init__(self, data=None, error=None): # noqa: E501 + """InlineResponse2007 - a model defined in OpenAPI""" # noqa: E501 + + self._data = None + self._error = None + self.discriminator = None + + if data is not None: + self.data = data + if error is not None: + self.error = error + + @property + def data(self): + """Gets the data of this InlineResponse2007. # noqa: E501 + + + :return: The data of this InlineResponse2007. # noqa: E501 + :rtype: InlineResponse2007Data + """ + return self._data + + @data.setter + def data(self, data): + """Sets the data of this InlineResponse2007. + + + :param data: The data of this InlineResponse2007. # noqa: E501 + :type: InlineResponse2007Data + """ + + self._data = data + + @property + def error(self): + """Gets the error of this InlineResponse2007. # noqa: E501 + + + :return: The error of this InlineResponse2007. # noqa: E501 + :rtype: object + """ + return self._error + + @error.setter + def error(self, error): + """Sets the error of this InlineResponse2007. + + + :param error: The error of this InlineResponse2007. # noqa: E501 + :type: object + """ + + self._error = error + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2007): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response2007_data.py b/pysky_api/openapi_client/models/inline_response2007_data.py new file mode 100644 index 00000000..55c20e1b --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response2007_data.py @@ -0,0 +1,113 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponse2007Data(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'version': 'int' + } + + attribute_map = { + 'version': 'version' + } + + def __init__(self, version=None): # noqa: E501 + """InlineResponse2007Data - a model defined in OpenAPI""" # noqa: E501 + + self._version = None + self.discriminator = None + + if version is not None: + self.version = version + + @property + def version(self): + """Gets the version of this InlineResponse2007Data. # noqa: E501 + + + :return: The version of this InlineResponse2007Data. # noqa: E501 + :rtype: int + """ + return self._version + + @version.setter + def version(self, version): + """Sets the version of this InlineResponse2007Data. + + + :param version: The version of this InlineResponse2007Data. # noqa: E501 + :type: int + """ + + self._version = version + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponse2007Data): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/models/inline_response_default.py b/pysky_api/openapi_client/models/inline_response_default.py new file mode 100644 index 00000000..aaf9c42e --- /dev/null +++ b/pysky_api/openapi_client/models/inline_response_default.py @@ -0,0 +1,139 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +import pprint +import re # noqa: F401 + +import six + + +class InlineResponseDefault(object): + """NOTE: This class is auto generated by OpenAPI Generator. + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + """ + Attributes: + openapi_types (dict): The key is attribute name + and the value is attribute type. + attribute_map (dict): The key is attribute name + and the value is json key in definition. + """ + openapi_types = { + 'code': 'int', + 'message': 'str' + } + + attribute_map = { + 'code': 'code', + 'message': 'message' + } + + def __init__(self, code=None, message=None): # noqa: E501 + """InlineResponseDefault - a model defined in OpenAPI""" # noqa: E501 + + self._code = None + self._message = None + self.discriminator = None + + if code is not None: + self.code = code + if message is not None: + self.message = message + + @property + def code(self): + """Gets the code of this InlineResponseDefault. # noqa: E501 + + + :return: The code of this InlineResponseDefault. # noqa: E501 + :rtype: int + """ + return self._code + + @code.setter + def code(self, code): + """Sets the code of this InlineResponseDefault. + + + :param code: The code of this InlineResponseDefault. # noqa: E501 + :type: int + """ + + self._code = code + + @property + def message(self): + """Gets the message of this InlineResponseDefault. # noqa: E501 + + + :return: The message of this InlineResponseDefault. # noqa: E501 + :rtype: str + """ + return self._message + + @message.setter + def message(self, message): + """Sets the message of this InlineResponseDefault. + + + :param message: The message of this InlineResponseDefault. # noqa: E501 + :type: str + """ + + self._message = message + + def to_dict(self): + """Returns the model properties as a dict""" + result = {} + + for attr, _ in six.iteritems(self.openapi_types): + value = getattr(self, attr) + if isinstance(value, list): + result[attr] = list(map( + lambda x: x.to_dict() if hasattr(x, "to_dict") else x, + value + )) + elif hasattr(value, "to_dict"): + result[attr] = value.to_dict() + elif isinstance(value, dict): + result[attr] = dict(map( + lambda item: (item[0], item[1].to_dict()) + if hasattr(item[1], "to_dict") else item, + value.items() + )) + else: + result[attr] = value + + return result + + def to_str(self): + """Returns the string representation of the model""" + return pprint.pformat(self.to_dict()) + + def __repr__(self): + """For `print` and `pprint`""" + return self.to_str() + + def __eq__(self, other): + """Returns true if both objects are equal""" + if not isinstance(other, InlineResponseDefault): + return False + + return self.__dict__ == other.__dict__ + + def __ne__(self, other): + """Returns true if both objects are not equal""" + return not self == other diff --git a/pysky_api/openapi_client/rest.py b/pysky_api/openapi_client/rest.py new file mode 100644 index 00000000..3a71f8a9 --- /dev/null +++ b/pysky_api/openapi_client/rest.py @@ -0,0 +1,323 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import io +import json +import logging +import re +import ssl + +import certifi +# python 2 and python 3 compatibility library +import six +from six.moves.urllib.parse import urlencode + +try: + import urllib3 +except ImportError: + raise ImportError('OpenAPI Python client requires urllib3.') + + +logger = logging.getLogger(__name__) + + +class RESTResponse(io.IOBase): + + def __init__(self, resp): + self.urllib3_response = resp + self.status = resp.status + self.reason = resp.reason + self.data = resp.data + + def getheaders(self): + """Returns a dictionary of the response headers.""" + return self.urllib3_response.getheaders() + + def getheader(self, name, default=None): + """Returns a given response header.""" + return self.urllib3_response.getheader(name, default) + + +class RESTClientObject(object): + + def __init__(self, configuration, pools_size=4, maxsize=None): + # urllib3.PoolManager will pass all kw parameters to connectionpool + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 + # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 + # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 + + # cert_reqs + if configuration.verify_ssl: + cert_reqs = ssl.CERT_REQUIRED + else: + cert_reqs = ssl.CERT_NONE + + # ca_certs + if configuration.ssl_ca_cert: + ca_certs = configuration.ssl_ca_cert + else: + # if not set certificate file, use Mozilla's root certificates. + ca_certs = certifi.where() + + addition_pool_args = {} + if configuration.assert_hostname is not None: + addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 + + if maxsize is None: + if configuration.connection_pool_maxsize is not None: + maxsize = configuration.connection_pool_maxsize + else: + maxsize = 4 + + # https pool manager + if configuration.proxy: + self.pool_manager = urllib3.ProxyManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + proxy_url=configuration.proxy, + **addition_pool_args + ) + else: + self.pool_manager = urllib3.PoolManager( + num_pools=pools_size, + maxsize=maxsize, + cert_reqs=cert_reqs, + ca_certs=ca_certs, + cert_file=configuration.cert_file, + key_file=configuration.key_file, + **addition_pool_args + ) + + def request(self, method, url, query_params=None, headers=None, + body=None, post_params=None, _preload_content=True, + _request_timeout=None): + """Perform requests. + + :param method: http request method + :param url: http request url + :param query_params: query parameters in the url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _preload_content: if False, the urllib3.HTTPResponse object will + be returned without reading/decoding response + data. Default is True. + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + """ + method = method.upper() + assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', + 'PATCH', 'OPTIONS'] + + if post_params and body: + raise ValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + + timeout = None + if _request_timeout: + if isinstance(_request_timeout, (int, ) if six.PY3 else (int, long)): # noqa: E501,F821 + timeout = urllib3.Timeout(total=_request_timeout) + elif (isinstance(_request_timeout, tuple) and + len(_request_timeout) == 2): + timeout = urllib3.Timeout( + connect=_request_timeout[0], read=_request_timeout[1]) + + if 'Content-Type' not in headers: + headers['Content-Type'] = 'application/json' + + try: + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + if query_params: + url += '?' + urlencode(query_params) + if re.search('json', headers['Content-Type'], re.IGNORECASE): + request_body = None + if body is not None: + request_body = json.dumps(body) + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=False, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + elif headers['Content-Type'] == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by urllib3 will be + # overwritten. + del headers['Content-Type'] + r = self.pool_manager.request( + method, url, + fields=post_params, + encode_multipart=True, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + # Pass a `string` parameter directly in the body to support + # other content types than Json when `body` argument is + # provided in serialized form + elif isinstance(body, str): + request_body = body + r = self.pool_manager.request( + method, url, + body=request_body, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + # For `GET`, `HEAD` + else: + r = self.pool_manager.request(method, url, + fields=query_params, + preload_content=_preload_content, + timeout=timeout, + headers=headers) + except urllib3.exceptions.SSLError as e: + msg = "{0}\n{1}".format(type(e).__name__, str(e)) + raise ApiException(status=0, reason=msg) + + if _preload_content: + r = RESTResponse(r) + + # In the python 3, the response.data is bytes. + # we need to decode it to string. + if six.PY3: + r.data = r.data.decode('utf8') + + # log response body + logger.debug("response body: %s", r.data) + + if not 200 <= r.status <= 299: + raise ApiException(http_resp=r) + + return r + + def GET(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("GET", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def HEAD(self, url, headers=None, query_params=None, _preload_content=True, + _request_timeout=None): + return self.request("HEAD", url, + headers=headers, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + query_params=query_params) + + def OPTIONS(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("OPTIONS", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def DELETE(self, url, headers=None, query_params=None, body=None, + _preload_content=True, _request_timeout=None): + return self.request("DELETE", url, + headers=headers, + query_params=query_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def POST(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("POST", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PUT(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PUT", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + def PATCH(self, url, headers=None, query_params=None, post_params=None, + body=None, _preload_content=True, _request_timeout=None): + return self.request("PATCH", url, + headers=headers, + query_params=query_params, + post_params=post_params, + _preload_content=_preload_content, + _request_timeout=_request_timeout, + body=body) + + +class ApiException(Exception): + + def __init__(self, status=None, reason=None, http_resp=None): + if http_resp: + self.status = http_resp.status + self.reason = http_resp.reason + self.body = http_resp.data + self.headers = http_resp.getheaders() + else: + self.status = status + self.reason = reason + self.body = None + self.headers = None + + def __str__(self): + """Custom error messages for exception""" + error_message = "({0})\n"\ + "Reason: {1}\n".format(self.status, self.reason) + if self.headers: + error_message += "HTTP response headers: {0}\n".format( + self.headers) + + if self.body: + error_message += "HTTP response body: {0}\n".format(self.body) + + return error_message diff --git a/pysky_api/requirements.txt b/pysky_api/requirements.txt new file mode 100644 index 00000000..bafdc075 --- /dev/null +++ b/pysky_api/requirements.txt @@ -0,0 +1,5 @@ +certifi >= 14.05.14 +six >= 1.10 +python_dateutil >= 2.5.3 +setuptools >= 21.0.0 +urllib3 >= 1.15.1 diff --git a/pysky_api/setup.py b/pysky_api/setup.py new file mode 100644 index 00000000..54a2f8c4 --- /dev/null +++ b/pysky_api/setup.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from setuptools import setup, find_packages # noqa: H301 + +NAME = "openapi-client" +VERSION = "1.0.0" +# To install the library, run the following +# +# python setup.py install +# +# prerequisite: setuptools +# http://pypi.python.org/pypi/setuptools + +REQUIRES = ["urllib3 >= 1.15", "six >= 1.10", "certifi", "python-dateutil"] + +setup( + name=NAME, + version=VERSION, + description="Skycoin REST API.", + author_email="contact@skycoin.net", + url="", + keywords=["OpenAPI", "OpenAPI-Generator", "Skycoin REST API."], + install_requires=REQUIRES, + packages=find_packages(), + include_package_data=True, + long_description="""\ + Skycoin is a next-generation cryptocurrency. # noqa: E501 + """ +) diff --git a/pysky_api/test-requirements.txt b/pysky_api/test-requirements.txt new file mode 100644 index 00000000..2702246c --- /dev/null +++ b/pysky_api/test-requirements.txt @@ -0,0 +1,5 @@ +coverage>=4.0.3 +nose>=1.3.7 +pluggy>=0.3.1 +py>=1.4.31 +randomize>=0.13 diff --git a/tests/restapi/__init__.py b/pysky_api/test/__init__.py similarity index 100% rename from tests/restapi/__init__.py rename to pysky_api/test/__init__.py diff --git a/pysky_api/test/test_apiv1exploreraddress_inputs.py b/pysky_api/test/test_apiv1exploreraddress_inputs.py new file mode 100644 index 00000000..1d750a4a --- /dev/null +++ b/pysky_api/test/test_apiv1exploreraddress_inputs.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1exploreraddress_inputs import Apiv1exploreraddressInputs # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1exploreraddressInputs(unittest.TestCase): + """Apiv1exploreraddressInputs unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1exploreraddressInputs(self): + """Test Apiv1exploreraddressInputs""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1exploreraddress_inputs.Apiv1exploreraddressInputs() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1exploreraddress_outputs.py b/pysky_api/test/test_apiv1exploreraddress_outputs.py new file mode 100644 index 00000000..28abb3c9 --- /dev/null +++ b/pysky_api/test/test_apiv1exploreraddress_outputs.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1exploreraddress_outputs import Apiv1exploreraddressOutputs # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1exploreraddressOutputs(unittest.TestCase): + """Apiv1exploreraddressOutputs unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1exploreraddressOutputs(self): + """Test Apiv1exploreraddressOutputs""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1exploreraddress_outputs.Apiv1exploreraddressOutputs() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1exploreraddress_status.py b/pysky_api/test/test_apiv1exploreraddress_status.py new file mode 100644 index 00000000..d02dd99d --- /dev/null +++ b/pysky_api/test/test_apiv1exploreraddress_status.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1exploreraddress_status import Apiv1exploreraddressStatus # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1exploreraddressStatus(unittest.TestCase): + """Apiv1exploreraddressStatus unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1exploreraddressStatus(self): + """Test Apiv1exploreraddressStatus""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1exploreraddress_status.Apiv1exploreraddressStatus() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1pending_txs_transaction.py b/pysky_api/test/test_apiv1pending_txs_transaction.py new file mode 100644 index 00000000..f80edffc --- /dev/null +++ b/pysky_api/test/test_apiv1pending_txs_transaction.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1pending_txs_transaction import Apiv1pendingTxsTransaction # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1pendingTxsTransaction(unittest.TestCase): + """Apiv1pendingTxsTransaction unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1pendingTxsTransaction(self): + """Test Apiv1pendingTxsTransaction""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1pending_txs_transaction.Apiv1pendingTxsTransaction() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1wallets_entries.py b/pysky_api/test/test_apiv1wallets_entries.py new file mode 100644 index 00000000..5aae69b0 --- /dev/null +++ b/pysky_api/test/test_apiv1wallets_entries.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1wallets_entries import Apiv1walletsEntries # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1walletsEntries(unittest.TestCase): + """Apiv1walletsEntries unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1walletsEntries(self): + """Test Apiv1walletsEntries""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1wallets_entries.Apiv1walletsEntries() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1wallets_meta.py b/pysky_api/test/test_apiv1wallets_meta.py new file mode 100644 index 00000000..a407dfad --- /dev/null +++ b/pysky_api/test/test_apiv1wallets_meta.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1wallets_meta import Apiv1walletsMeta # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1walletsMeta(unittest.TestCase): + """Apiv1walletsMeta unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1walletsMeta(self): + """Test Apiv1walletsMeta""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1wallets_meta.Apiv1walletsMeta() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1wallettransaction_hours_selection.py b/pysky_api/test/test_apiv1wallettransaction_hours_selection.py new file mode 100644 index 00000000..5a74a866 --- /dev/null +++ b/pysky_api/test/test_apiv1wallettransaction_hours_selection.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1wallettransaction_hours_selection import Apiv1wallettransactionHoursSelection # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1wallettransactionHoursSelection(unittest.TestCase): + """Apiv1wallettransactionHoursSelection unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1wallettransactionHoursSelection(self): + """Test Apiv1wallettransactionHoursSelection""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1wallettransaction_hours_selection.Apiv1wallettransactionHoursSelection() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1wallettransaction_to.py b/pysky_api/test/test_apiv1wallettransaction_to.py new file mode 100644 index 00000000..7920a714 --- /dev/null +++ b/pysky_api/test/test_apiv1wallettransaction_to.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1wallettransaction_to import Apiv1wallettransactionTo # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1wallettransactionTo(unittest.TestCase): + """Apiv1wallettransactionTo unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1wallettransactionTo(self): + """Test Apiv1wallettransactionTo""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1wallettransaction_to.Apiv1wallettransactionTo() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_apiv1wallettransaction_wallet.py b/pysky_api/test/test_apiv1wallettransaction_wallet.py new file mode 100644 index 00000000..6b056b39 --- /dev/null +++ b/pysky_api/test/test_apiv1wallettransaction_wallet.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.apiv1wallettransaction_wallet import Apiv1wallettransactionWallet # noqa: E501 +from openapi_client.rest import ApiException + + +class TestApiv1wallettransactionWallet(unittest.TestCase): + """Apiv1wallettransactionWallet unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testApiv1wallettransactionWallet(self): + """Test Apiv1wallettransactionWallet""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.apiv1wallettransaction_wallet.Apiv1wallettransactionWallet() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_default_api.py b/pysky_api/test/test_default_api.py new file mode 100644 index 00000000..c4afd6fa --- /dev/null +++ b/pysky_api/test/test_default_api.py @@ -0,0 +1,371 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.api.default_api import DefaultApi # noqa: E501 +from openapi_client.rest import ApiException + + +class TestDefaultApi(unittest.TestCase): + """DefaultApi unit test stubs""" + + def setUp(self): + self.api = openapi_client.api.default_api.DefaultApi() # noqa: E501 + + def tearDown(self): + pass + + def test_address_count(self): + """Test case for address_count + + Returns the total number of unique address that have coins. # noqa: E501 + """ + pass + + def test_address_uxouts(self): + """Test case for address_uxouts + + """ + pass + + def test_balance_get(self): + """Test case for balance_get + + Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + """ + pass + + def test_balance_post(self): + """Test case for balance_post + + Returns the balance of one or more addresses, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + """ + pass + + def test_block(self): + """Test case for block + + """ + pass + + def test_blockchain_metadata(self): + """Test case for blockchain_metadata + + Returns the blockchain metadata. # noqa: E501 + """ + pass + + def test_blockchain_progress(self): + """Test case for blockchain_progress + + Returns the blockchain sync progress. # noqa: E501 + """ + pass + + def test_blocks_get(self): + """Test case for blocks_get + + blocksHandler returns blocks between a start and end point, # noqa: E501 + """ + pass + + def test_blocks_post(self): + """Test case for blocks_post + + blocksHandler returns blocks between a start and end point, # noqa: E501 + """ + pass + + def test_coin_supply(self): + """Test case for coin_supply + + """ + pass + + def test_csrf(self): + """Test case for csrf + + Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 + """ + pass + + def test_default_connections(self): + """Test case for default_connections + + defaultConnectionsHandler returns the list of default hardcoded bootstrap addresses.\\n They are not necessarily connected to. # noqa: E501 + """ + pass + + def test_explorer_address(self): + """Test case for explorer_address + + """ + pass + + def test_health(self): + """Test case for health + + Returns node health data. # noqa: E501 + """ + pass + + def test_last_blocks(self): + """Test case for last_blocks + + """ + pass + + def test_network_connection(self): + """Test case for network_connection + + This endpoint returns a specific connection. # noqa: E501 + """ + pass + + def test_network_connections(self): + """Test case for network_connections + + This endpoint returns all outgoings connections. # noqa: E501 + """ + pass + + def test_network_connections_disconnect(self): + """Test case for network_connections_disconnect + + """ + pass + + def test_network_connections_exchange(self): + """Test case for network_connections_exchange + + """ + pass + + def test_network_connections_trust(self): + """Test case for network_connections_trust + + trustConnectionsHandler returns all trusted connections.\\n They are not necessarily connected to. In the default configuration, these will be a subset of the default hardcoded bootstrap addresses. # noqa: E501 + """ + pass + + def test_outputs_get(self): + """Test case for outputs_get + + If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + """ + pass + + def test_outputs_post(self): + """Test case for outputs_post + + If neither addrs nor hashes are specificed, return all unspent outputs. If only one filter is specified, then return outputs match the filter. Both filters cannot be specified. # noqa: E501 + """ + pass + + def test_pending_txs(self): + """Test case for pending_txs + + """ + pass + + def test_resend_unconfirmed_txns(self): + """Test case for resend_unconfirmed_txns + + """ + pass + + def test_richlist(self): + """Test case for richlist + + Returns the top skycoin holders. # noqa: E501 + """ + pass + + def test_transaction(self): + """Test case for transaction + + """ + pass + + def test_transaction_inject(self): + """Test case for transaction_inject + + Broadcast a hex-encoded, serialized transaction to the network. # noqa: E501 + """ + pass + + def test_transaction_raw(self): + """Test case for transaction_raw + + Returns the hex-encoded byte serialization of a transaction. The transaction may be confirmed or unconfirmed. # noqa: E501 + """ + pass + + def test_transaction_verify(self): + """Test case for transaction_verify + + """ + pass + + def test_transactions_get(self): + """Test case for transactions_get + + Returns transactions that match the filters. # noqa: E501 + """ + pass + + def test_transactions_post(self): + """Test case for transactions_post + + Returns transactions that match the filters. # noqa: E501 + """ + pass + + def test_uxout(self): + """Test case for uxout + + Returns an unspent output by ID. # noqa: E501 + """ + pass + + def test_verify_address(self): + """Test case for verify_address + + Verifies a Skycoin address. # noqa: E501 + """ + pass + + def test_version(self): + """Test case for version + + """ + pass + + def test_wallet(self): + """Test case for wallet + + Returns a wallet by id. # noqa: E501 + """ + pass + + def test_wallet_balance(self): + """Test case for wallet_balance + + Returns the wallet's balance, both confirmed and predicted. The predicted balance is the confirmed balance minus the pending spends. # noqa: E501 + """ + pass + + def test_wallet_create(self): + """Test case for wallet_create + + """ + pass + + def test_wallet_decrypt(self): + """Test case for wallet_decrypt + + Decrypts wallet. # noqa: E501 + """ + pass + + def test_wallet_encrypt(self): + """Test case for wallet_encrypt + + Encrypt wallet. # noqa: E501 + """ + pass + + def test_wallet_folder(self): + """Test case for wallet_folder + + """ + pass + + def test_wallet_new_address(self): + """Test case for wallet_new_address + + """ + pass + + def test_wallet_new_seed(self): + """Test case for wallet_new_seed + + """ + pass + + def test_wallet_recover(self): + """Test case for wallet_recover + + Recovers an encrypted wallet by providing the seed. The first address will be generated from seed and compared to the first address of the specified wallet. If they match, the wallet will be regenerated with an optional password. If the wallet is not encrypted, an error is returned. # noqa: E501 + """ + pass + + def test_wallet_seed(self): + """Test case for wallet_seed + + This endpoint only works for encrypted wallets. If the wallet is unencrypted, The seed will be not returned. # noqa: E501 + """ + pass + + def test_wallet_seed_verify(self): + """Test case for wallet_seed_verify + + Verifies a wallet seed. # noqa: E501 + """ + pass + + def test_wallet_spent(self): + """Test case for wallet_spent + + """ + pass + + def test_wallet_transaction(self): + """Test case for wallet_transaction + + """ + pass + + def test_wallet_transactions(self): + """Test case for wallet_transactions + + """ + pass + + def test_wallet_unload(self): + """Test case for wallet_unload + + Unloads wallet from the wallet service. # noqa: E501 + """ + pass + + def test_wallet_update(self): + """Test case for wallet_update + + Update the wallet. # noqa: E501 + """ + pass + + def test_wallets(self): + """Test case for wallets + + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_object.py b/pysky_api/test/test_inline_object.py new file mode 100644 index 00000000..421d9cc4 --- /dev/null +++ b/pysky_api/test/test_inline_object.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_object import InlineObject # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineObject(unittest.TestCase): + """InlineObject unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineObject(self): + """Test InlineObject""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_object.InlineObject() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response200.py b/pysky_api/test/test_inline_response200.py new file mode 100644 index 00000000..b2d65e3b --- /dev/null +++ b/pysky_api/test/test_inline_response200.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response200 import InlineResponse200 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse200(unittest.TestCase): + """InlineResponse200 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse200(self): + """Test InlineResponse200""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response200.InlineResponse200() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2001.py b/pysky_api/test/test_inline_response2001.py new file mode 100644 index 00000000..c336f2b2 --- /dev/null +++ b/pysky_api/test/test_inline_response2001.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2001 import InlineResponse2001 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2001(unittest.TestCase): + """InlineResponse2001 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2001(self): + """Test InlineResponse2001""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2001.InlineResponse2001() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2002.py b/pysky_api/test/test_inline_response2002.py new file mode 100644 index 00000000..9380efa4 --- /dev/null +++ b/pysky_api/test/test_inline_response2002.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2002 import InlineResponse2002 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2002(unittest.TestCase): + """InlineResponse2002 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2002(self): + """Test InlineResponse2002""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2002.InlineResponse2002() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2003.py b/pysky_api/test/test_inline_response2003.py new file mode 100644 index 00000000..1eac22a8 --- /dev/null +++ b/pysky_api/test/test_inline_response2003.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2003 import InlineResponse2003 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2003(unittest.TestCase): + """InlineResponse2003 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2003(self): + """Test InlineResponse2003""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2003.InlineResponse2003() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py b/pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py new file mode 100644 index 00000000..a5396cc9 --- /dev/null +++ b/pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2003_unconfirmed_verify_transaction import InlineResponse2003UnconfirmedVerifyTransaction # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2003UnconfirmedVerifyTransaction(unittest.TestCase): + """InlineResponse2003UnconfirmedVerifyTransaction unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2003UnconfirmedVerifyTransaction(self): + """Test InlineResponse2003UnconfirmedVerifyTransaction""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2003_unconfirmed_verify_transaction.InlineResponse2003UnconfirmedVerifyTransaction() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2004.py b/pysky_api/test/test_inline_response2004.py new file mode 100644 index 00000000..fd2d7bb4 --- /dev/null +++ b/pysky_api/test/test_inline_response2004.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2004 import InlineResponse2004 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2004(unittest.TestCase): + """InlineResponse2004 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2004(self): + """Test InlineResponse2004""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2004.InlineResponse2004() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2005.py b/pysky_api/test/test_inline_response2005.py new file mode 100644 index 00000000..22525d19 --- /dev/null +++ b/pysky_api/test/test_inline_response2005.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2005 import InlineResponse2005 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2005(unittest.TestCase): + """InlineResponse2005 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2005(self): + """Test InlineResponse2005""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2005.InlineResponse2005() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2006.py b/pysky_api/test/test_inline_response2006.py new file mode 100644 index 00000000..6351560b --- /dev/null +++ b/pysky_api/test/test_inline_response2006.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2006 import InlineResponse2006 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2006(unittest.TestCase): + """InlineResponse2006 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2006(self): + """Test InlineResponse2006""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2006.InlineResponse2006() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2007.py b/pysky_api/test/test_inline_response2007.py new file mode 100644 index 00000000..b1346e61 --- /dev/null +++ b/pysky_api/test/test_inline_response2007.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2007 import InlineResponse2007 # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2007(unittest.TestCase): + """InlineResponse2007 unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2007(self): + """Test InlineResponse2007""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2007.InlineResponse2007() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pysky_api/test/test_inline_response2007_data.py b/pysky_api/test/test_inline_response2007_data.py new file mode 100644 index 00000000..71c29303 --- /dev/null +++ b/pysky_api/test/test_inline_response2007_data.py @@ -0,0 +1,40 @@ +# coding: utf-8 + +""" + Skycoin REST API. + + Skycoin is a next-generation cryptocurrency. # noqa: E501 + + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech +""" + + +from __future__ import absolute_import + +import unittest + +import openapi_client +from openapi_client.models.inline_response2007_data import InlineResponse2007Data # noqa: E501 +from openapi_client.rest import ApiException + + +class TestInlineResponse2007Data(unittest.TestCase): + """InlineResponse2007Data unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def testInlineResponse2007Data(self): + """Test InlineResponse2007Data""" + # FIXME: construct object with mandatory attributes with example values + # model = openapi_client.models.inline_response2007_data.InlineResponse2007Data() # noqa: E501 + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/restapi/test_inline_response_default.py b/pysky_api/test/test_inline_response_default.py similarity index 55% rename from tests/restapi/test_inline_response_default.py rename to pysky_api/test/test_inline_response_default.py index df1d7ff5..21776f66 100644 --- a/tests/restapi/test_inline_response_default.py +++ b/pysky_api/test/test_inline_response_default.py @@ -1,12 +1,13 @@ # coding: utf-8 """ + Skycoin REST API. - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 + Skycoin is a next-generation cryptocurrency. # noqa: E501 - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git + OpenAPI spec version: 0.25.1 + Contact: skycoin.doe@example.com + Generated by: https://openapi-generator.tech """ @@ -14,9 +15,9 @@ import unittest -import swagger_client -from swagger_client.models.inline_response_default import InlineResponseDefault # noqa: E501 -from swagger_client.rest import ApiException +import openapi_client +from openapi_client.models.inline_response_default import InlineResponseDefault # noqa: E501 +from openapi_client.rest import ApiException class TestInlineResponseDefault(unittest.TestCase): @@ -31,7 +32,7 @@ def tearDown(self): def testInlineResponseDefault(self): """Test InlineResponseDefault""" # FIXME: construct object with mandatory attributes with example values - # model = swagger_client.models.inline_response_default.InlineResponseDefault() # noqa: E501 + # model = openapi_client.models.inline_response_default.InlineResponseDefault() # noqa: E501 pass diff --git a/tox.swagger.ini b/pysky_api/tox.ini similarity index 89% rename from tox.swagger.ini rename to pysky_api/tox.ini index 1cf0829d..3d0be613 100644 --- a/tox.swagger.ini +++ b/pysky_api/tox.ini @@ -4,7 +4,7 @@ envlist = py27, py3 [testenv] deps=-r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt - + commands= nosetests \ - [] \ No newline at end of file + [] diff --git a/skycoin/skycoin.py b/skycoin/skycoin.py index bde837bf..a9f6847b 100644 --- a/skycoin/skycoin.py +++ b/skycoin/skycoin.py @@ -641,1273 +641,1353 @@ def __init__(self): GoSlice_swigregister(GoSlice) -def SKY_cipher_Ripemd160_Set(p0, p1): - return _skycoin.SKY_cipher_Ripemd160_Set(p0, p1) -SKY_cipher_Ripemd160_Set = _skycoin.SKY_cipher_Ripemd160_Set +def SKY_cipher_RandByte(p0): + return _skycoin.SKY_cipher_RandByte(p0) +SKY_cipher_RandByte = _skycoin.SKY_cipher_RandByte -def SKY_cipher_HashRipemd160(p0, p1): - return _skycoin.SKY_cipher_HashRipemd160(p0, p1) -SKY_cipher_HashRipemd160 = _skycoin.SKY_cipher_HashRipemd160 +def SKY_cipher_NewPubKey(p0, p1): + return _skycoin.SKY_cipher_NewPubKey(p0, p1) +SKY_cipher_NewPubKey = _skycoin.SKY_cipher_NewPubKey -def SKY_cipher_SHA256_Set(p0, p1): - return _skycoin.SKY_cipher_SHA256_Set(p0, p1) -SKY_cipher_SHA256_Set = _skycoin.SKY_cipher_SHA256_Set +def SKY_cipher_PubKeyFromHex(p0, p1): + return _skycoin.SKY_cipher_PubKeyFromHex(p0, p1) +SKY_cipher_PubKeyFromHex = _skycoin.SKY_cipher_PubKeyFromHex -def SKY_cipher_SHA256_Hex(p0): - return _skycoin.SKY_cipher_SHA256_Hex(p0) -SKY_cipher_SHA256_Hex = _skycoin.SKY_cipher_SHA256_Hex +def SKY_cipher_PubKeyFromSecKey(p0, p1): + return _skycoin.SKY_cipher_PubKeyFromSecKey(p0, p1) +SKY_cipher_PubKeyFromSecKey = _skycoin.SKY_cipher_PubKeyFromSecKey -def SKY_cipher_SHA256_Xor(p0, p1, p2): - return _skycoin.SKY_cipher_SHA256_Xor(p0, p1, p2) -SKY_cipher_SHA256_Xor = _skycoin.SKY_cipher_SHA256_Xor +def SKY_cipher_PubKeyFromSig(p0, p1, p2): + return _skycoin.SKY_cipher_PubKeyFromSig(p0, p1, p2) +SKY_cipher_PubKeyFromSig = _skycoin.SKY_cipher_PubKeyFromSig -def SKY_cipher_SumSHA256(p0, p1): - return _skycoin.SKY_cipher_SumSHA256(p0, p1) -SKY_cipher_SumSHA256 = _skycoin.SKY_cipher_SumSHA256 +def SKY_cipher_PubKey_Verify(p0): + return _skycoin.SKY_cipher_PubKey_Verify(p0) +SKY_cipher_PubKey_Verify = _skycoin.SKY_cipher_PubKey_Verify -def SKY_cipher_SHA256FromHex(p0, p1): - return _skycoin.SKY_cipher_SHA256FromHex(p0, p1) -SKY_cipher_SHA256FromHex = _skycoin.SKY_cipher_SHA256FromHex +def SKY_cipher_PubKey_Hex(p0): + return _skycoin.SKY_cipher_PubKey_Hex(p0) +SKY_cipher_PubKey_Hex = _skycoin.SKY_cipher_PubKey_Hex -def SKY_cipher_DoubleSHA256(p0, p1): - return _skycoin.SKY_cipher_DoubleSHA256(p0, p1) -SKY_cipher_DoubleSHA256 = _skycoin.SKY_cipher_DoubleSHA256 +def SKY_cipher_PubKeyRipemd160(p0, p1): + return _skycoin.SKY_cipher_PubKeyRipemd160(p0, p1) +SKY_cipher_PubKeyRipemd160 = _skycoin.SKY_cipher_PubKeyRipemd160 -def SKY_cipher_AddSHA256(p0, p1, p2): - return _skycoin.SKY_cipher_AddSHA256(p0, p1, p2) -SKY_cipher_AddSHA256 = _skycoin.SKY_cipher_AddSHA256 +def SKY_cipher_NewSecKey(p0, p1): + return _skycoin.SKY_cipher_NewSecKey(p0, p1) +SKY_cipher_NewSecKey = _skycoin.SKY_cipher_NewSecKey -def SKY_cipher_Merkle(p0, p1): - return _skycoin.SKY_cipher_Merkle(p0, p1) -SKY_cipher_Merkle = _skycoin.SKY_cipher_Merkle +def SKY_cipher_SecKeyFromHex(p0, p1): + return _skycoin.SKY_cipher_SecKeyFromHex(p0, p1) +SKY_cipher_SecKeyFromHex = _skycoin.SKY_cipher_SecKeyFromHex -def SKY_cipher_SHA256_Null(p0): - return _skycoin.SKY_cipher_SHA256_Null(p0) -SKY_cipher_SHA256_Null = _skycoin.SKY_cipher_SHA256_Null +def SKY_cipher_SecKey_Verify(p0): + return _skycoin.SKY_cipher_SecKey_Verify(p0) +SKY_cipher_SecKey_Verify = _skycoin.SKY_cipher_SecKey_Verify -def SKY_base58_String2Hex(p0): - return _skycoin.SKY_base58_String2Hex(p0) -SKY_base58_String2Hex = _skycoin.SKY_base58_String2Hex +def SKY_cipher_SecKey_Hex(p0): + return _skycoin.SKY_cipher_SecKey_Hex(p0) +SKY_cipher_SecKey_Hex = _skycoin.SKY_cipher_SecKey_Hex -def SKY_base58_Base58_ToInt(p0): - return _skycoin.SKY_base58_Base58_ToInt(p0) -SKY_base58_Base58_ToInt = _skycoin.SKY_base58_Base58_ToInt +def SKY_cipher_ECDH(p0, p1): + return _skycoin.SKY_cipher_ECDH(p0, p1) +SKY_cipher_ECDH = _skycoin.SKY_cipher_ECDH -def SKY_base58_Base58_ToHex(p0): - return _skycoin.SKY_base58_Base58_ToHex(p0) -SKY_base58_Base58_ToHex = _skycoin.SKY_base58_Base58_ToHex +def SKY_cipher_NewSig(p0, p1): + return _skycoin.SKY_cipher_NewSig(p0, p1) +SKY_cipher_NewSig = _skycoin.SKY_cipher_NewSig -def SKY_base58_Base58_Base582Int(p0): - return _skycoin.SKY_base58_Base58_Base582Int(p0) -SKY_base58_Base58_Base582Int = _skycoin.SKY_base58_Base58_Base582Int +def SKY_cipher_SigFromHex(p0, p1): + return _skycoin.SKY_cipher_SigFromHex(p0, p1) +SKY_cipher_SigFromHex = _skycoin.SKY_cipher_SigFromHex -def SKY_base58_Base582Hex(p0): - return _skycoin.SKY_base58_Base582Hex(p0) -SKY_base58_Base582Hex = _skycoin.SKY_base58_Base582Hex +def SKY_cipher_Sig_Hex(p0): + return _skycoin.SKY_cipher_Sig_Hex(p0) +SKY_cipher_Sig_Hex = _skycoin.SKY_cipher_Sig_Hex -def SKY_base58_Base58_BitHex(p0): - return _skycoin.SKY_base58_Base58_BitHex(p0) -SKY_base58_Base58_BitHex = _skycoin.SKY_base58_Base58_BitHex +def SKY_cipher_SignHash(p0, p1, p2): + return _skycoin.SKY_cipher_SignHash(p0, p1, p2) +SKY_cipher_SignHash = _skycoin.SKY_cipher_SignHash -def SKY_base58_Int2Base58(p0): - return _skycoin.SKY_base58_Int2Base58(p0) -SKY_base58_Int2Base58 = _skycoin.SKY_base58_Int2Base58 +def SKY_cipher_VerifyAddressSignedHash(p0, p1, p2): + return _skycoin.SKY_cipher_VerifyAddressSignedHash(p0, p1, p2) +SKY_cipher_VerifyAddressSignedHash = _skycoin.SKY_cipher_VerifyAddressSignedHash -def SKY_base58_Hex2Base58(p0): - return _skycoin.SKY_base58_Hex2Base58(p0) -SKY_base58_Hex2Base58 = _skycoin.SKY_base58_Hex2Base58 +def SKY_cipher_VerifySignedHash(p0, p1): + return _skycoin.SKY_cipher_VerifySignedHash(p0, p1) +SKY_cipher_VerifySignedHash = _skycoin.SKY_cipher_VerifySignedHash -def SKY_base58_Hex2Base58String(p0): - return _skycoin.SKY_base58_Hex2Base58String(p0) -SKY_base58_Hex2Base58String = _skycoin.SKY_base58_Hex2Base58String +def SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2): + return _skycoin.SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2) +SKY_cipher_VerifyPubKeySignedHash = _skycoin.SKY_cipher_VerifyPubKeySignedHash -def SKY_base58_Hex2Base58Str(p0): - return _skycoin.SKY_base58_Hex2Base58Str(p0) -SKY_base58_Hex2Base58Str = _skycoin.SKY_base58_Hex2Base58Str +def SKY_cipher_GenerateKeyPair(p0, p1): + return _skycoin.SKY_cipher_GenerateKeyPair(p0, p1) +SKY_cipher_GenerateKeyPair = _skycoin.SKY_cipher_GenerateKeyPair -def SKY_cli_GenerateAddressesInFile(p0, p1, p2): - return _skycoin.SKY_cli_GenerateAddressesInFile(p0, p1, p2) -SKY_cli_GenerateAddressesInFile = _skycoin.SKY_cli_GenerateAddressesInFile +def SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2): + return _skycoin.SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2) +SKY_cipher_GenerateDeterministicKeyPair = _skycoin.SKY_cipher_GenerateDeterministicKeyPair -def SKY_cli_FormatAddressesAsJSON(p0): - return _skycoin.SKY_cli_FormatAddressesAsJSON(p0) -SKY_cli_FormatAddressesAsJSON = _skycoin.SKY_cli_FormatAddressesAsJSON +def SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3): + return _skycoin.SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3) +SKY_cipher_DeterministicKeyPairIterator = _skycoin.SKY_cipher_DeterministicKeyPairIterator -def SKY_cli_FormatAddressesAsJoinedArray(p0): - return _skycoin.SKY_cli_FormatAddressesAsJoinedArray(p0) -SKY_cli_FormatAddressesAsJoinedArray = _skycoin.SKY_cli_FormatAddressesAsJoinedArray +def SKY_cipher_GenerateDeterministicKeyPairs(*args): + return _skycoin.SKY_cipher_GenerateDeterministicKeyPairs(*args) +SKY_cipher_GenerateDeterministicKeyPairs = _skycoin.SKY_cipher_GenerateDeterministicKeyPairs -def SKY_cli_AddressesToStrings(p0): - return _skycoin.SKY_cli_AddressesToStrings(p0) -SKY_cli_AddressesToStrings = _skycoin.SKY_cli_AddressesToStrings +def SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1): + return _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1) +SKY_cipher_GenerateDeterministicKeyPairsSeed = _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed -def SKY_coin_NewBlock(p0, p1, p2, p3, p4): - return _skycoin.SKY_coin_NewBlock(p0, p1, p2, p3, p4) -SKY_coin_NewBlock = _skycoin.SKY_coin_NewBlock +def SKY_cipher_CheckSecKey(p0): + return _skycoin.SKY_cipher_CheckSecKey(p0) +SKY_cipher_CheckSecKey = _skycoin.SKY_cipher_CheckSecKey -def SKY_coin_SignedBlock_VerifySignature(p0, p1): - return _skycoin.SKY_coin_SignedBlock_VerifySignature(p0, p1) -SKY_coin_SignedBlock_VerifySignature = _skycoin.SKY_coin_SignedBlock_VerifySignature +def SKY_cipher_CheckSecKeyHash(p0, p1): + return _skycoin.SKY_cipher_CheckSecKeyHash(p0, p1) +SKY_cipher_CheckSecKeyHash = _skycoin.SKY_cipher_CheckSecKeyHash -def SKY_coin_NewGenesisBlock(p0, p1, p2): - return _skycoin.SKY_coin_NewGenesisBlock(p0, p1, p2) -SKY_coin_NewGenesisBlock = _skycoin.SKY_coin_NewGenesisBlock +def SKY_cipher_DecodeBase58BitcoinAddress(p0, p1): + return _skycoin.SKY_cipher_DecodeBase58BitcoinAddress(p0, p1) +SKY_cipher_DecodeBase58BitcoinAddress = _skycoin.SKY_cipher_DecodeBase58BitcoinAddress -def SKY_coin_Block_HashHeader(p0, p1): - return _skycoin.SKY_coin_Block_HashHeader(p0, p1) -SKY_coin_Block_HashHeader = _skycoin.SKY_coin_Block_HashHeader +def SKY_cipher_BitcoinAddressFromPubKey(p0, p1): + return _skycoin.SKY_cipher_BitcoinAddressFromPubKey(p0, p1) +SKY_cipher_BitcoinAddressFromPubKey = _skycoin.SKY_cipher_BitcoinAddressFromPubKey -def SKY_coin_Block_PreHashHeader(p0, p1): - return _skycoin.SKY_coin_Block_PreHashHeader(p0, p1) -SKY_coin_Block_PreHashHeader = _skycoin.SKY_coin_Block_PreHashHeader +def SKY_cipher_BitcoinAddressFromSecKey(p0, p1): + return _skycoin.SKY_cipher_BitcoinAddressFromSecKey(p0, p1) +SKY_cipher_BitcoinAddressFromSecKey = _skycoin.SKY_cipher_BitcoinAddressFromSecKey -def SKY_coin_Block_Time(p0): - return _skycoin.SKY_coin_Block_Time(p0) -SKY_coin_Block_Time = _skycoin.SKY_coin_Block_Time +def SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0): + return _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0) +SKY_cipher_BitcoinWalletImportFormatFromSeckey = _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey -def SKY_coin_Block_Seq(p0): - return _skycoin.SKY_coin_Block_Seq(p0) -SKY_coin_Block_Seq = _skycoin.SKY_coin_Block_Seq +def SKY_cipher_BitcoinAddressFromBytes(p0, p1): + return _skycoin.SKY_cipher_BitcoinAddressFromBytes(p0, p1) +SKY_cipher_BitcoinAddressFromBytes = _skycoin.SKY_cipher_BitcoinAddressFromBytes -def SKY_coin_Block_HashBody(p0, p1): - return _skycoin.SKY_coin_Block_HashBody(p0, p1) -SKY_coin_Block_HashBody = _skycoin.SKY_coin_Block_HashBody +def SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1): + return _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1) +SKY_cipher_SecKeyFromBitcoinWalletImportFormat = _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat -def SKY_coin_Block_Size(p0): - return _skycoin.SKY_coin_Block_Size(p0) -SKY_coin_Block_Size = _skycoin.SKY_coin_Block_Size +def SKY_cipher_BitcoinAddress_Null(p0): + return _skycoin.SKY_cipher_BitcoinAddress_Null(p0) +SKY_cipher_BitcoinAddress_Null = _skycoin.SKY_cipher_BitcoinAddress_Null -def SKY_coin_Block_String(p0): - return _skycoin.SKY_coin_Block_String(p0) -SKY_coin_Block_String = _skycoin.SKY_coin_Block_String +def SKY_cipher_BitcoinAddress_Bytes(p0): + return _skycoin.SKY_cipher_BitcoinAddress_Bytes(p0) +SKY_cipher_BitcoinAddress_Bytes = _skycoin.SKY_cipher_BitcoinAddress_Bytes -def SKY_coin_Block_GetTransaction(p0, p1): - return _skycoin.SKY_coin_Block_GetTransaction(p0, p1) -SKY_coin_Block_GetTransaction = _skycoin.SKY_coin_Block_GetTransaction +def SKY_cipher_BitcoinAddress_Verify(p0, p1): + return _skycoin.SKY_cipher_BitcoinAddress_Verify(p0, p1) +SKY_cipher_BitcoinAddress_Verify = _skycoin.SKY_cipher_BitcoinAddress_Verify -def SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5): - return _skycoin.SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5) -SKY_coin_NewBlockHeader = _skycoin.SKY_coin_NewBlockHeader +def SKY_cipher_BitcoinAddress_String(p0): + return _skycoin.SKY_cipher_BitcoinAddress_String(p0) +SKY_cipher_BitcoinAddress_String = _skycoin.SKY_cipher_BitcoinAddress_String -def SKY_coin_BlockHeader_Hash(p0, p1): - return _skycoin.SKY_coin_BlockHeader_Hash(p0, p1) -SKY_coin_BlockHeader_Hash = _skycoin.SKY_coin_BlockHeader_Hash +def SKY_cipher_BitcoinAddress_Checksum(p0, p1): + return _skycoin.SKY_cipher_BitcoinAddress_Checksum(p0, p1) +SKY_cipher_BitcoinAddress_Checksum = _skycoin.SKY_cipher_BitcoinAddress_Checksum + +def SKY_api_NewCreateTransactionResponse(p0, p1): + return _skycoin.SKY_api_NewCreateTransactionResponse(p0, p1) +SKY_api_NewCreateTransactionResponse = _skycoin.SKY_api_NewCreateTransactionResponse + +def SKY_api_NewCreatedTransaction(p0, p1): + return _skycoin.SKY_api_NewCreatedTransaction(p0, p1) +SKY_api_NewCreatedTransaction = _skycoin.SKY_api_NewCreatedTransaction + +def SKY_api_CreatedTransaction_ToTransaction(p0): + return _skycoin.SKY_api_CreatedTransaction_ToTransaction(p0) +SKY_api_CreatedTransaction_ToTransaction = _skycoin.SKY_api_CreatedTransaction_ToTransaction + +def SKY_api_NewCreatedTransactionOutput(p0, p1): + return _skycoin.SKY_api_NewCreatedTransactionOutput(p0, p1) +SKY_api_NewCreatedTransactionOutput = _skycoin.SKY_api_NewCreatedTransactionOutput + +def SKY_api_NewCreatedTransactionInput(p0): + return _skycoin.SKY_api_NewCreatedTransactionInput(p0) +SKY_api_NewCreatedTransactionInput = _skycoin.SKY_api_NewCreatedTransactionInput + +def SKY_iputil_LocalhostIP(): + return _skycoin.SKY_iputil_LocalhostIP() +SKY_iputil_LocalhostIP = _skycoin.SKY_iputil_LocalhostIP + +def SKY_iputil_IsLocalhost(p0): + return _skycoin.SKY_iputil_IsLocalhost(p0) +SKY_iputil_IsLocalhost = _skycoin.SKY_iputil_IsLocalhost + +def SKY_iputil_SplitAddr(p0): + return _skycoin.SKY_iputil_SplitAddr(p0) +SKY_iputil_SplitAddr = _skycoin.SKY_iputil_SplitAddr + +def SKY_testutil_MakeAddress(p0): + return _skycoin.SKY_testutil_MakeAddress(p0) +SKY_testutil_MakeAddress = _skycoin.SKY_testutil_MakeAddress + +def SKY_coin_Create_Transaction(): + return _skycoin.SKY_coin_Create_Transaction() +SKY_coin_Create_Transaction = _skycoin.SKY_coin_Create_Transaction + +def SKY_coin_Transaction_Copy(p0): + return _skycoin.SKY_coin_Transaction_Copy(p0) +SKY_coin_Transaction_Copy = _skycoin.SKY_coin_Transaction_Copy + +def SKY_coin_GetTransactionObject(p0): + return _skycoin.SKY_coin_GetTransactionObject(p0) +SKY_coin_GetTransactionObject = _skycoin.SKY_coin_GetTransactionObject + +def SKY_coin_Transaction_ResetInputs(p0, p1): + return _skycoin.SKY_coin_Transaction_ResetInputs(p0, p1) +SKY_coin_Transaction_ResetInputs = _skycoin.SKY_coin_Transaction_ResetInputs + +def SKY_coin_Transaction_GetInputsCount(p0): + return _skycoin.SKY_coin_Transaction_GetInputsCount(p0) +SKY_coin_Transaction_GetInputsCount = _skycoin.SKY_coin_Transaction_GetInputsCount + +def SKY_coin_Transaction_GetInputAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_GetInputAt(p0, p1, p2) +SKY_coin_Transaction_GetInputAt = _skycoin.SKY_coin_Transaction_GetInputAt -def SKY_coin_BlockHeader_Bytes(p0): - return _skycoin.SKY_coin_BlockHeader_Bytes(p0) -SKY_coin_BlockHeader_Bytes = _skycoin.SKY_coin_BlockHeader_Bytes +def SKY_coin_Transaction_SetInputAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_SetInputAt(p0, p1, p2) +SKY_coin_Transaction_SetInputAt = _skycoin.SKY_coin_Transaction_SetInputAt -def SKY_coin_BlockHeader_String(p0): - return _skycoin.SKY_coin_BlockHeader_String(p0) -SKY_coin_BlockHeader_String = _skycoin.SKY_coin_BlockHeader_String +def SKY_coin_Transaction_GetOutputsCount(p0): + return _skycoin.SKY_coin_Transaction_GetOutputsCount(p0) +SKY_coin_Transaction_GetOutputsCount = _skycoin.SKY_coin_Transaction_GetOutputsCount -def SKY_coin_BlockBody_Hash(p0, p1): - return _skycoin.SKY_coin_BlockBody_Hash(p0, p1) -SKY_coin_BlockBody_Hash = _skycoin.SKY_coin_BlockBody_Hash +def SKY_coin_Transaction_GetOutputAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_GetOutputAt(p0, p1, p2) +SKY_coin_Transaction_GetOutputAt = _skycoin.SKY_coin_Transaction_GetOutputAt -def SKY_coin_BlockBody_Size(): - return _skycoin.SKY_coin_BlockBody_Size() -SKY_coin_BlockBody_Size = _skycoin.SKY_coin_BlockBody_Size +def SKY_coin_Transaction_SetOutputAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_SetOutputAt(p0, p1, p2) +SKY_coin_Transaction_SetOutputAt = _skycoin.SKY_coin_Transaction_SetOutputAt -def SKY_coin_BlockBody_Bytes(p0): - return _skycoin.SKY_coin_BlockBody_Bytes(p0) -SKY_coin_BlockBody_Bytes = _skycoin.SKY_coin_BlockBody_Bytes +def SKY_coin_Transaction_GetSignaturesCount(p0): + return _skycoin.SKY_coin_Transaction_GetSignaturesCount(p0) +SKY_coin_Transaction_GetSignaturesCount = _skycoin.SKY_coin_Transaction_GetSignaturesCount -def SKY_coin_CreateUnspents(*args): - return _skycoin.SKY_coin_CreateUnspents(*args) -SKY_coin_CreateUnspents = _skycoin.SKY_coin_CreateUnspents +def SKY_coin_Transaction_GetSignatureAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_GetSignatureAt(p0, p1, p2) +SKY_coin_Transaction_GetSignatureAt = _skycoin.SKY_coin_Transaction_GetSignatureAt -def SKY_coin_CreateUnspent(p0, p1, p2, p3): - return _skycoin.SKY_coin_CreateUnspent(p0, p1, p2, p3) -SKY_coin_CreateUnspent = _skycoin.SKY_coin_CreateUnspent +def SKY_coin_Transaction_SetSignatureAt(p0, p1, p2): + return _skycoin.SKY_coin_Transaction_SetSignatureAt(p0, p1, p2) +SKY_coin_Transaction_SetSignatureAt = _skycoin.SKY_coin_Transaction_SetSignatureAt -def SKY_coin_GetBlockObject(p0): - return _skycoin.SKY_coin_GetBlockObject(p0) -SKY_coin_GetBlockObject = _skycoin.SKY_coin_GetBlockObject +def SKY_coin_Transaction_PushSignature(p0, p1): + return _skycoin.SKY_coin_Transaction_PushSignature(p0, p1) +SKY_coin_Transaction_PushSignature = _skycoin.SKY_coin_Transaction_PushSignature -def SKY_coin_GetBlockBody(p0): - return _skycoin.SKY_coin_GetBlockBody(p0) -SKY_coin_GetBlockBody = _skycoin.SKY_coin_GetBlockBody +def SKY_coin_Transaction_ResetOutputs(p0, p1): + return _skycoin.SKY_coin_Transaction_ResetOutputs(p0, p1) +SKY_coin_Transaction_ResetOutputs = _skycoin.SKY_coin_Transaction_ResetOutputs -def SKY_coin_NewEmptyBlock(p0): - return _skycoin.SKY_coin_NewEmptyBlock(p0) -SKY_coin_NewEmptyBlock = _skycoin.SKY_coin_NewEmptyBlock +def SKY_coin_Transaction_ResetSignatures(p0, p1): + return _skycoin.SKY_coin_Transaction_ResetSignatures(p0, p1) +SKY_coin_Transaction_ResetSignatures = _skycoin.SKY_coin_Transaction_ResetSignatures -def SKY_httphelper_Address_UnmarshalJSON(p0, p1): - return _skycoin.SKY_httphelper_Address_UnmarshalJSON(p0, p1) -SKY_httphelper_Address_UnmarshalJSON = _skycoin.SKY_httphelper_Address_UnmarshalJSON +def SKY_coin_Transaction_Verify(p0): + return _skycoin.SKY_coin_Transaction_Verify(p0) +SKY_coin_Transaction_Verify = _skycoin.SKY_coin_Transaction_Verify -def SKY_httphelper_Address_MarshalJSON(p0): - return _skycoin.SKY_httphelper_Address_MarshalJSON(p0) -SKY_httphelper_Address_MarshalJSON = _skycoin.SKY_httphelper_Address_MarshalJSON +def SKY_coin_Transaction_VerifyInput(*args): + return _skycoin.SKY_coin_Transaction_VerifyInput(*args) +SKY_coin_Transaction_VerifyInput = _skycoin.SKY_coin_Transaction_VerifyInput -def SKY_httphelper_Coins_UnmarshalJSON(p1): - return _skycoin.SKY_httphelper_Coins_UnmarshalJSON(p1) -SKY_httphelper_Coins_UnmarshalJSON = _skycoin.SKY_httphelper_Coins_UnmarshalJSON +def SKY_coin_Transaction_PushInput(p0, p1): + return _skycoin.SKY_coin_Transaction_PushInput(p0, p1) +SKY_coin_Transaction_PushInput = _skycoin.SKY_coin_Transaction_PushInput -def SKY_httphelper_Coins_MarshalJSON(): - return _skycoin.SKY_httphelper_Coins_MarshalJSON() -SKY_httphelper_Coins_MarshalJSON = _skycoin.SKY_httphelper_Coins_MarshalJSON +def SKY_coin_TransactionOutput_UxID(p0, p1, p2): + return _skycoin.SKY_coin_TransactionOutput_UxID(p0, p1, p2) +SKY_coin_TransactionOutput_UxID = _skycoin.SKY_coin_TransactionOutput_UxID -def SKY_httphelper_Coins_Value(): - return _skycoin.SKY_httphelper_Coins_Value() -SKY_httphelper_Coins_Value = _skycoin.SKY_httphelper_Coins_Value +def SKY_coin_Transaction_PushOutput(p0, p1, p2, p3): + return _skycoin.SKY_coin_Transaction_PushOutput(p0, p1, p2, p3) +SKY_coin_Transaction_PushOutput = _skycoin.SKY_coin_Transaction_PushOutput -def SKY_httphelper_Hours_UnmarshalJSON(p1): - return _skycoin.SKY_httphelper_Hours_UnmarshalJSON(p1) -SKY_httphelper_Hours_UnmarshalJSON = _skycoin.SKY_httphelper_Hours_UnmarshalJSON +def SKY_coin_Transaction_SignInputs(*args): + return _skycoin.SKY_coin_Transaction_SignInputs(*args) +SKY_coin_Transaction_SignInputs = _skycoin.SKY_coin_Transaction_SignInputs -def SKY_httphelper_Hours_MarshalJSON(): - return _skycoin.SKY_httphelper_Hours_MarshalJSON() -SKY_httphelper_Hours_MarshalJSON = _skycoin.SKY_httphelper_Hours_MarshalJSON +def SKY_coin_Transaction_Size(p0): + return _skycoin.SKY_coin_Transaction_Size(p0) +SKY_coin_Transaction_Size = _skycoin.SKY_coin_Transaction_Size -def SKY_httphelper_Hours_Value(): - return _skycoin.SKY_httphelper_Hours_Value() -SKY_httphelper_Hours_Value = _skycoin.SKY_httphelper_Hours_Value +def SKY_coin_Transaction_Hash(p0, p1): + return _skycoin.SKY_coin_Transaction_Hash(p0, p1) +SKY_coin_Transaction_Hash = _skycoin.SKY_coin_Transaction_Hash -def SKY_wallet_NewBalance(p0, p1, p2): - return _skycoin.SKY_wallet_NewBalance(p0, p1, p2) -SKY_wallet_NewBalance = _skycoin.SKY_wallet_NewBalance +def SKY_coin_Transaction_SizeHash(p0, p2): + return _skycoin.SKY_coin_Transaction_SizeHash(p0, p2) +SKY_coin_Transaction_SizeHash = _skycoin.SKY_coin_Transaction_SizeHash -def SKY_wallet_NewBalanceFromUxOut(p0, p1, p2): - return _skycoin.SKY_wallet_NewBalanceFromUxOut(p0, p1, p2) -SKY_wallet_NewBalanceFromUxOut = _skycoin.SKY_wallet_NewBalanceFromUxOut +def SKY_coin_Transaction_TxID(p0): + return _skycoin.SKY_coin_Transaction_TxID(p0) +SKY_coin_Transaction_TxID = _skycoin.SKY_coin_Transaction_TxID -def SKY_wallet_Balance_Add(p0, p1, p2): - return _skycoin.SKY_wallet_Balance_Add(p0, p1, p2) -SKY_wallet_Balance_Add = _skycoin.SKY_wallet_Balance_Add +def SKY_coin_Transaction_TxIDHex(p0): + return _skycoin.SKY_coin_Transaction_TxIDHex(p0) +SKY_coin_Transaction_TxIDHex = _skycoin.SKY_coin_Transaction_TxIDHex -def SKY_wallet_Balance_Sub(p0, p1, p2): - return _skycoin.SKY_wallet_Balance_Sub(p0, p1, p2) -SKY_wallet_Balance_Sub = _skycoin.SKY_wallet_Balance_Sub +def SKY_coin_Transaction_UpdateHeader(p0): + return _skycoin.SKY_coin_Transaction_UpdateHeader(p0) +SKY_coin_Transaction_UpdateHeader = _skycoin.SKY_coin_Transaction_UpdateHeader -def SKY_wallet_Balance_Equals(p0, p1): - return _skycoin.SKY_wallet_Balance_Equals(p0, p1) -SKY_wallet_Balance_Equals = _skycoin.SKY_wallet_Balance_Equals +def SKY_coin_Transaction_HashInner(p0, p1): + return _skycoin.SKY_coin_Transaction_HashInner(p0, p1) +SKY_coin_Transaction_HashInner = _skycoin.SKY_coin_Transaction_HashInner -def SKY_wallet_Balance_IsZero(p0): - return _skycoin.SKY_wallet_Balance_IsZero(p0) -SKY_wallet_Balance_IsZero = _skycoin.SKY_wallet_Balance_IsZero +def SKY_coin_Transaction_Serialize(p0): + return _skycoin.SKY_coin_Transaction_Serialize(p0) +SKY_coin_Transaction_Serialize = _skycoin.SKY_coin_Transaction_Serialize -def SKY_wallet_CryptoTypeFromString(p0): - return _skycoin.SKY_wallet_CryptoTypeFromString(p0) -SKY_wallet_CryptoTypeFromString = _skycoin.SKY_wallet_CryptoTypeFromString +def SKY_coin_TransactionDeserialize(p0): + return _skycoin.SKY_coin_TransactionDeserialize(p0) +SKY_coin_TransactionDeserialize = _skycoin.SKY_coin_TransactionDeserialize -def SKY_cli_AddPrivateKey(p0, p1): - return _skycoin.SKY_cli_AddPrivateKey(p0, p1) -SKY_cli_AddPrivateKey = _skycoin.SKY_cli_AddPrivateKey +def SKY_coin_Transaction_OutputHours(p0): + return _skycoin.SKY_coin_Transaction_OutputHours(p0) +SKY_coin_Transaction_OutputHours = _skycoin.SKY_coin_Transaction_OutputHours -def SKY_cli_AddPrivateKeyToFile(p0, p1, p2): - return _skycoin.SKY_cli_AddPrivateKeyToFile(p0, p1, p2) -SKY_cli_AddPrivateKeyToFile = _skycoin.SKY_cli_AddPrivateKeyToFile +def SKY_coin_Create_Transactions(): + return _skycoin.SKY_coin_Create_Transactions() +SKY_coin_Create_Transactions = _skycoin.SKY_coin_Create_Transactions -def SKY_api_NewCreateTransactionResponse(p0, p1): - return _skycoin.SKY_api_NewCreateTransactionResponse(p0, p1) -SKY_api_NewCreateTransactionResponse = _skycoin.SKY_api_NewCreateTransactionResponse +def SKY_coin_GetTransactionsObject(p0, p1): + return _skycoin.SKY_coin_GetTransactionsObject(p0, p1) +SKY_coin_GetTransactionsObject = _skycoin.SKY_coin_GetTransactionsObject -def SKY_api_NewCreatedTransaction(p0, p1): - return _skycoin.SKY_api_NewCreatedTransaction(p0, p1) -SKY_api_NewCreatedTransaction = _skycoin.SKY_api_NewCreatedTransaction +def SKY_coin_Transactions_Length(p0): + return _skycoin.SKY_coin_Transactions_Length(p0) +SKY_coin_Transactions_Length = _skycoin.SKY_coin_Transactions_Length -def SKY_api_CreatedTransaction_ToTransaction(p0): - return _skycoin.SKY_api_CreatedTransaction_ToTransaction(p0) -SKY_api_CreatedTransaction_ToTransaction = _skycoin.SKY_api_CreatedTransaction_ToTransaction +def SKY_coin_Transactions_Add(p0, p1): + return _skycoin.SKY_coin_Transactions_Add(p0, p1) +SKY_coin_Transactions_Add = _skycoin.SKY_coin_Transactions_Add -def SKY_api_NewCreatedTransactionOutput(p0, p1): - return _skycoin.SKY_api_NewCreatedTransactionOutput(p0, p1) -SKY_api_NewCreatedTransactionOutput = _skycoin.SKY_api_NewCreatedTransactionOutput +def SKY_coin_Transactions_Fees(p0, p1): + return _skycoin.SKY_coin_Transactions_Fees(p0, p1) +SKY_coin_Transactions_Fees = _skycoin.SKY_coin_Transactions_Fees -def SKY_api_NewCreatedTransactionInput(p0): - return _skycoin.SKY_api_NewCreatedTransactionInput(p0) -SKY_api_NewCreatedTransactionInput = _skycoin.SKY_api_NewCreatedTransactionInput +def SKY_coin_Transactions_GetAt(p0, p1): + return _skycoin.SKY_coin_Transactions_GetAt(p0, p1) +SKY_coin_Transactions_GetAt = _skycoin.SKY_coin_Transactions_GetAt -def SKY_logging_EnableColors(): - return _skycoin.SKY_logging_EnableColors() -SKY_logging_EnableColors = _skycoin.SKY_logging_EnableColors +def SKY_coin_Transactions_Hashes(*args): + return _skycoin.SKY_coin_Transactions_Hashes(*args) +SKY_coin_Transactions_Hashes = _skycoin.SKY_coin_Transactions_Hashes -def SKY_logging_DisableColors(): - return _skycoin.SKY_logging_DisableColors() -SKY_logging_DisableColors = _skycoin.SKY_logging_DisableColors +def SKY_coin_Transactions_Size(p0): + return _skycoin.SKY_coin_Transactions_Size(p0) +SKY_coin_Transactions_Size = _skycoin.SKY_coin_Transactions_Size -def SKY_logging_Disable(): - return _skycoin.SKY_logging_Disable() -SKY_logging_Disable = _skycoin.SKY_logging_Disable +def SKY_coin_Transactions_TruncateBytesTo(p0, p1): + return _skycoin.SKY_coin_Transactions_TruncateBytesTo(p0, p1) +SKY_coin_Transactions_TruncateBytesTo = _skycoin.SKY_coin_Transactions_TruncateBytesTo -def SKY_file_InitDataDir(p0): - return _skycoin.SKY_file_InitDataDir(p0) -SKY_file_InitDataDir = _skycoin.SKY_file_InitDataDir +def SKY_coin_SortTransactions(p0, p1): + return _skycoin.SKY_coin_SortTransactions(p0, p1) +SKY_coin_SortTransactions = _skycoin.SKY_coin_SortTransactions -def SKY_file_UserHome(): - return _skycoin.SKY_file_UserHome() -SKY_file_UserHome = _skycoin.SKY_file_UserHome +def SKY_coin_NewSortableTransactions(p0, p1, p2): + return _skycoin.SKY_coin_NewSortableTransactions(p0, p1, p2) +SKY_coin_NewSortableTransactions = _skycoin.SKY_coin_NewSortableTransactions -def SKY_file_ResolveResourceDirectory(p0): - return _skycoin.SKY_file_ResolveResourceDirectory(p0) -SKY_file_ResolveResourceDirectory = _skycoin.SKY_file_ResolveResourceDirectory +def SKY_coin_SortableTransactions_Sort(p0): + return _skycoin.SKY_coin_SortableTransactions_Sort(p0) +SKY_coin_SortableTransactions_Sort = _skycoin.SKY_coin_SortableTransactions_Sort -def SKY_file_DetermineResourcePath(p0, p1, p2): - return _skycoin.SKY_file_DetermineResourcePath(p0, p1, p2) -SKY_file_DetermineResourcePath = _skycoin.SKY_file_DetermineResourcePath +def SKY_coin_SortableTransactions_Len(p0): + return _skycoin.SKY_coin_SortableTransactions_Len(p0) +SKY_coin_SortableTransactions_Len = _skycoin.SKY_coin_SortableTransactions_Len -def SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6): - return _skycoin.SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6) -SKY_wallet_CreateOptionsHandle = _skycoin.SKY_wallet_CreateOptionsHandle +def SKY_coin_SortableTransactions_Less(p0, p1, p2): + return _skycoin.SKY_coin_SortableTransactions_Less(p0, p1, p2) +SKY_coin_SortableTransactions_Less = _skycoin.SKY_coin_SortableTransactions_Less -def SKY_cli_LoadConfig(): - return _skycoin.SKY_cli_LoadConfig() -SKY_cli_LoadConfig = _skycoin.SKY_cli_LoadConfig +def SKY_coin_SortableTransactions_Swap(p0, p1, p2): + return _skycoin.SKY_coin_SortableTransactions_Swap(p0, p1, p2) +SKY_coin_SortableTransactions_Swap = _skycoin.SKY_coin_SortableTransactions_Swap -def SKY_cli_Config_FullWalletPath(p0): - return _skycoin.SKY_cli_Config_FullWalletPath(p0) -SKY_cli_Config_FullWalletPath = _skycoin.SKY_cli_Config_FullWalletPath +def SKY_coin_VerifyTransactionCoinsSpending(*args): + return _skycoin.SKY_coin_VerifyTransactionCoinsSpending(*args) +SKY_coin_VerifyTransactionCoinsSpending = _skycoin.SKY_coin_VerifyTransactionCoinsSpending + +def SKY_coin_VerifyTransactionHoursSpending(*args): + return _skycoin.SKY_coin_VerifyTransactionHoursSpending(*args) +SKY_coin_VerifyTransactionHoursSpending = _skycoin.SKY_coin_VerifyTransactionHoursSpending -def SKY_cli_Config_FullDBPath(p0): - return _skycoin.SKY_cli_Config_FullDBPath(p0) -SKY_cli_Config_FullDBPath = _skycoin.SKY_cli_Config_FullDBPath +def SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2): + return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2) +SKY_encrypt_ScryptChacha20poly1305_Encrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt -def SKY_cli_NewApp(p0): - return _skycoin.SKY_cli_NewApp(p0) -SKY_cli_NewApp = _skycoin.SKY_cli_NewApp +def SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2): + return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2) +SKY_encrypt_ScryptChacha20poly1305_Decrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt -def SKY_cli_RPCClientFromContext(p0): - return _skycoin.SKY_cli_RPCClientFromContext(p0) -SKY_cli_RPCClientFromContext = _skycoin.SKY_cli_RPCClientFromContext +def SKY_cli_GenerateWallet(p0, p2): + return _skycoin.SKY_cli_GenerateWallet(p0, p2) +SKY_cli_GenerateWallet = _skycoin.SKY_cli_GenerateWallet -def SKY_cli_ConfigFromContext(p0): - return _skycoin.SKY_cli_ConfigFromContext(p0) -SKY_cli_ConfigFromContext = _skycoin.SKY_cli_ConfigFromContext +def SKY_cli_MakeAlphanumericSeed(): + return _skycoin.SKY_cli_MakeAlphanumericSeed() +SKY_cli_MakeAlphanumericSeed = _skycoin.SKY_cli_MakeAlphanumericSeed -def SKY_cli_PasswordFromBytes_Password(): - return _skycoin.SKY_cli_PasswordFromBytes_Password() -SKY_cli_PasswordFromBytes_Password = _skycoin.SKY_cli_PasswordFromBytes_Password +def SKY_cli_AddPrivateKey(p0, p1): + return _skycoin.SKY_cli_AddPrivateKey(p0, p1) +SKY_cli_AddPrivateKey = _skycoin.SKY_cli_AddPrivateKey -def SKY_cli_PasswordFromTerm_Password(): - return _skycoin.SKY_cli_PasswordFromTerm_Password() -SKY_cli_PasswordFromTerm_Password = _skycoin.SKY_cli_PasswordFromTerm_Password +def SKY_cli_AddPrivateKeyToFile(p0, p1, p2): + return _skycoin.SKY_cli_AddPrivateKeyToFile(p0, p1, p2) +SKY_cli_AddPrivateKeyToFile = _skycoin.SKY_cli_AddPrivateKeyToFile -def SKY_coin_UxOut_Hash(p0, p1): - return _skycoin.SKY_coin_UxOut_Hash(p0, p1) -SKY_coin_UxOut_Hash = _skycoin.SKY_coin_UxOut_Hash +def SKY_base58_String2Hex(p0): + return _skycoin.SKY_base58_String2Hex(p0) +SKY_base58_String2Hex = _skycoin.SKY_base58_String2Hex -def SKY_coin_UxOut_SnapshotHash(p0, p1): - return _skycoin.SKY_coin_UxOut_SnapshotHash(p0, p1) -SKY_coin_UxOut_SnapshotHash = _skycoin.SKY_coin_UxOut_SnapshotHash +def SKY_base58_Base58_ToInt(p0): + return _skycoin.SKY_base58_Base58_ToInt(p0) +SKY_base58_Base58_ToInt = _skycoin.SKY_base58_Base58_ToInt -def SKY_coin_UxBody_Hash(p0, p1): - return _skycoin.SKY_coin_UxBody_Hash(p0, p1) -SKY_coin_UxBody_Hash = _skycoin.SKY_coin_UxBody_Hash +def SKY_base58_Base58_ToHex(p0): + return _skycoin.SKY_base58_Base58_ToHex(p0) +SKY_base58_Base58_ToHex = _skycoin.SKY_base58_Base58_ToHex -def SKY_coin_UxOut_CoinHours(p0, p1): - return _skycoin.SKY_coin_UxOut_CoinHours(p0, p1) -SKY_coin_UxOut_CoinHours = _skycoin.SKY_coin_UxOut_CoinHours +def SKY_base58_Base58_Base582Int(p0): + return _skycoin.SKY_base58_Base58_Base582Int(p0) +SKY_base58_Base58_Base582Int = _skycoin.SKY_base58_Base58_Base582Int -def SKY_coin_UxArray_Hashes(*args): - return _skycoin.SKY_coin_UxArray_Hashes(*args) -SKY_coin_UxArray_Hashes = _skycoin.SKY_coin_UxArray_Hashes +def SKY_base58_Base582Hex(p0): + return _skycoin.SKY_base58_Base582Hex(p0) +SKY_base58_Base582Hex = _skycoin.SKY_base58_Base582Hex -def SKY_coin_UxArray_HasDupes(*args): - return _skycoin.SKY_coin_UxArray_HasDupes(*args) -SKY_coin_UxArray_HasDupes = _skycoin.SKY_coin_UxArray_HasDupes +def SKY_base58_Base58_BitHex(p0): + return _skycoin.SKY_base58_Base58_BitHex(p0) +SKY_base58_Base58_BitHex = _skycoin.SKY_base58_Base58_BitHex -def SKY_coin_UxArray_Sort(): - return _skycoin.SKY_coin_UxArray_Sort() -SKY_coin_UxArray_Sort = _skycoin.SKY_coin_UxArray_Sort +def SKY_base58_Int2Base58(p0): + return _skycoin.SKY_base58_Int2Base58(p0) +SKY_base58_Int2Base58 = _skycoin.SKY_base58_Int2Base58 -def SKY_coin_UxArray_Len(): - return _skycoin.SKY_coin_UxArray_Len() -SKY_coin_UxArray_Len = _skycoin.SKY_coin_UxArray_Len +def SKY_base58_Hex2Base58(p0): + return _skycoin.SKY_base58_Hex2Base58(p0) +SKY_base58_Hex2Base58 = _skycoin.SKY_base58_Hex2Base58 -def SKY_coin_UxArray_Less(*args): - return _skycoin.SKY_coin_UxArray_Less(*args) -SKY_coin_UxArray_Less = _skycoin.SKY_coin_UxArray_Less +def SKY_base58_Hex2Base58String(p0): + return _skycoin.SKY_base58_Hex2Base58String(p0) +SKY_base58_Hex2Base58String = _skycoin.SKY_base58_Hex2Base58String -def SKY_coin_UxArray_Swap(*args): - return _skycoin.SKY_coin_UxArray_Swap(*args) -SKY_coin_UxArray_Swap = _skycoin.SKY_coin_UxArray_Swap +def SKY_base58_Hex2Base58Str(p0): + return _skycoin.SKY_base58_Hex2Base58Str(p0) +SKY_base58_Hex2Base58Str = _skycoin.SKY_base58_Hex2Base58Str -def SKY_coin_UxArray_Coins(*args): - return _skycoin.SKY_coin_UxArray_Coins(*args) -SKY_coin_UxArray_Coins = _skycoin.SKY_coin_UxArray_Coins +def SKY_handle_close(p0): + return _skycoin.SKY_handle_close(p0) +SKY_handle_close = _skycoin.SKY_handle_close -def SKY_coin_UxArray_CoinHours(*args): - return _skycoin.SKY_coin_UxArray_CoinHours(*args) -SKY_coin_UxArray_CoinHours = _skycoin.SKY_coin_UxArray_CoinHours +def SKY_handle_copy(p0): + return _skycoin.SKY_handle_copy(p0) +SKY_handle_copy = _skycoin.SKY_handle_copy -def SKY_coin_UxArray_Sub(*args): - return _skycoin.SKY_coin_UxArray_Sub(*args) -SKY_coin_UxArray_Sub = _skycoin.SKY_coin_UxArray_Sub +def SKY_apputil_CatchInterruptPanic(): + return _skycoin.SKY_apputil_CatchInterruptPanic() +SKY_apputil_CatchInterruptPanic = _skycoin.SKY_apputil_CatchInterruptPanic -def SKY_coin_UxArray_Add(*args): - return _skycoin.SKY_coin_UxArray_Add(*args) -SKY_coin_UxArray_Add = _skycoin.SKY_coin_UxArray_Add +def SKY_apputil_CatchDebug(): + return _skycoin.SKY_apputil_CatchDebug() +SKY_apputil_CatchDebug = _skycoin.SKY_apputil_CatchDebug -def SKY_coin_NewAddressUxOuts(*args): - return _skycoin.SKY_coin_NewAddressUxOuts(*args) -SKY_coin_NewAddressUxOuts = _skycoin.SKY_coin_NewAddressUxOuts +def SKY_apputil_PrintProgramStatus(): + return _skycoin.SKY_apputil_PrintProgramStatus() +SKY_apputil_PrintProgramStatus = _skycoin.SKY_apputil_PrintProgramStatus -def SKY_coin_AddressUxOuts_Keys(*args): - return _skycoin.SKY_coin_AddressUxOuts_Keys(*args) -SKY_coin_AddressUxOuts_Keys = _skycoin.SKY_coin_AddressUxOuts_Keys +def SKY_fee_VerifyTransactionFee(p0, p1, p2): + return _skycoin.SKY_fee_VerifyTransactionFee(p0, p1, p2) +SKY_fee_VerifyTransactionFee = _skycoin.SKY_fee_VerifyTransactionFee -def SKY_coin_AddressUxOuts_Flatten(*args): - return _skycoin.SKY_coin_AddressUxOuts_Flatten(*args) -SKY_coin_AddressUxOuts_Flatten = _skycoin.SKY_coin_AddressUxOuts_Flatten +def SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2): + return _skycoin.SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2) +SKY_fee_VerifyTransactionFeeForHours = _skycoin.SKY_fee_VerifyTransactionFeeForHours -def SKY_coin_AddressUxOuts_Sub(p0, p1): - return _skycoin.SKY_coin_AddressUxOuts_Sub(p0, p1) -SKY_coin_AddressUxOuts_Sub = _skycoin.SKY_coin_AddressUxOuts_Sub +def SKY_fee_RequiredFee(p0, p1): + return _skycoin.SKY_fee_RequiredFee(p0, p1) +SKY_fee_RequiredFee = _skycoin.SKY_fee_RequiredFee -def SKY_coin_AddressUxOuts_Add(p0, p1): - return _skycoin.SKY_coin_AddressUxOuts_Add(p0, p1) -SKY_coin_AddressUxOuts_Add = _skycoin.SKY_coin_AddressUxOuts_Add +def SKY_fee_RemainingHours(p0, p1): + return _skycoin.SKY_fee_RemainingHours(p0, p1) +SKY_fee_RemainingHours = _skycoin.SKY_fee_RemainingHours -def SKY_coin_AddressUxOuts_Get(*args): - return _skycoin.SKY_coin_AddressUxOuts_Get(*args) -SKY_coin_AddressUxOuts_Get = _skycoin.SKY_coin_AddressUxOuts_Get +def SKY_fee_TransactionFee(*args): + return _skycoin.SKY_fee_TransactionFee(*args) +SKY_fee_TransactionFee = _skycoin.SKY_fee_TransactionFee -def SKY_coin_AddressUxOuts_HasKey(p0, p1): - return _skycoin.SKY_coin_AddressUxOuts_HasKey(p0, p1) -SKY_coin_AddressUxOuts_HasKey = _skycoin.SKY_coin_AddressUxOuts_HasKey +def SKY_cli_GenerateAddressesInFile(p0, p1, p2): + return _skycoin.SKY_cli_GenerateAddressesInFile(p0, p1, p2) +SKY_cli_GenerateAddressesInFile = _skycoin.SKY_cli_GenerateAddressesInFile -def SKY_coin_AddressUxOuts_GetOutputLength(p0, p1): - return _skycoin.SKY_coin_AddressUxOuts_GetOutputLength(p0, p1) -SKY_coin_AddressUxOuts_GetOutputLength = _skycoin.SKY_coin_AddressUxOuts_GetOutputLength +def SKY_cli_FormatAddressesAsJSON(p0): + return _skycoin.SKY_cli_FormatAddressesAsJSON(p0) +SKY_cli_FormatAddressesAsJSON = _skycoin.SKY_cli_FormatAddressesAsJSON -def SKY_coin_AddressUxOuts_Length(p0): - return _skycoin.SKY_coin_AddressUxOuts_Length(p0) -SKY_coin_AddressUxOuts_Length = _skycoin.SKY_coin_AddressUxOuts_Length +def SKY_cli_FormatAddressesAsJoinedArray(p0): + return _skycoin.SKY_cli_FormatAddressesAsJoinedArray(p0) +SKY_cli_FormatAddressesAsJoinedArray = _skycoin.SKY_cli_FormatAddressesAsJoinedArray -def SKY_coin_AddressUxOuts_Set(*args): - return _skycoin.SKY_coin_AddressUxOuts_Set(*args) -SKY_coin_AddressUxOuts_Set = _skycoin.SKY_coin_AddressUxOuts_Set +def SKY_cli_AddressesToStrings(p0): + return _skycoin.SKY_cli_AddressesToStrings(p0) +SKY_cli_AddressesToStrings = _skycoin.SKY_cli_AddressesToStrings -def SKY_cipher_RandByte(p0): - return _skycoin.SKY_cipher_RandByte(p0) -SKY_cipher_RandByte = _skycoin.SKY_cipher_RandByte +def SKY_cli_CheckWalletBalance(p0, p1, p2): + return _skycoin.SKY_cli_CheckWalletBalance(p0, p1, p2) +SKY_cli_CheckWalletBalance = _skycoin.SKY_cli_CheckWalletBalance -def SKY_cipher_NewPubKey(p0, p1): - return _skycoin.SKY_cipher_NewPubKey(p0, p1) -SKY_cipher_NewPubKey = _skycoin.SKY_cipher_NewPubKey +def SKY_cli_GetBalanceOfAddresses(p0, p1, p2): + return _skycoin.SKY_cli_GetBalanceOfAddresses(p0, p1, p2) +SKY_cli_GetBalanceOfAddresses = _skycoin.SKY_cli_GetBalanceOfAddresses -def SKY_cipher_PubKeyFromHex(p0, p1): - return _skycoin.SKY_cipher_PubKeyFromHex(p0, p1) -SKY_cipher_PubKeyFromHex = _skycoin.SKY_cipher_PubKeyFromHex +def SKY_certutil_NewTLSCertPair(p0, p1, p2): + return _skycoin.SKY_certutil_NewTLSCertPair(p0, p1, p2) +SKY_certutil_NewTLSCertPair = _skycoin.SKY_certutil_NewTLSCertPair -def SKY_cipher_PubKeyFromSecKey(p0, p1): - return _skycoin.SKY_cipher_PubKeyFromSecKey(p0, p1) -SKY_cipher_PubKeyFromSecKey = _skycoin.SKY_cipher_PubKeyFromSecKey +def SKY_coin_NewBlock(p0, p1, p2, p3, p4): + return _skycoin.SKY_coin_NewBlock(p0, p1, p2, p3, p4) +SKY_coin_NewBlock = _skycoin.SKY_coin_NewBlock -def SKY_cipher_PubKeyFromSig(p0, p1, p2): - return _skycoin.SKY_cipher_PubKeyFromSig(p0, p1, p2) -SKY_cipher_PubKeyFromSig = _skycoin.SKY_cipher_PubKeyFromSig +def SKY_coin_SignedBlock_VerifySignature(p0, p1): + return _skycoin.SKY_coin_SignedBlock_VerifySignature(p0, p1) +SKY_coin_SignedBlock_VerifySignature = _skycoin.SKY_coin_SignedBlock_VerifySignature -def SKY_cipher_PubKey_Verify(p0): - return _skycoin.SKY_cipher_PubKey_Verify(p0) -SKY_cipher_PubKey_Verify = _skycoin.SKY_cipher_PubKey_Verify +def SKY_coin_NewGenesisBlock(p0, p1, p2): + return _skycoin.SKY_coin_NewGenesisBlock(p0, p1, p2) +SKY_coin_NewGenesisBlock = _skycoin.SKY_coin_NewGenesisBlock -def SKY_cipher_PubKey_Hex(p0): - return _skycoin.SKY_cipher_PubKey_Hex(p0) -SKY_cipher_PubKey_Hex = _skycoin.SKY_cipher_PubKey_Hex +def SKY_coin_Block_HashHeader(p0, p1): + return _skycoin.SKY_coin_Block_HashHeader(p0, p1) +SKY_coin_Block_HashHeader = _skycoin.SKY_coin_Block_HashHeader -def SKY_cipher_PubKeyRipemd160(p0, p1): - return _skycoin.SKY_cipher_PubKeyRipemd160(p0, p1) -SKY_cipher_PubKeyRipemd160 = _skycoin.SKY_cipher_PubKeyRipemd160 +def SKY_coin_Block_PreHashHeader(p0, p1): + return _skycoin.SKY_coin_Block_PreHashHeader(p0, p1) +SKY_coin_Block_PreHashHeader = _skycoin.SKY_coin_Block_PreHashHeader -def SKY_cipher_NewSecKey(p0, p1): - return _skycoin.SKY_cipher_NewSecKey(p0, p1) -SKY_cipher_NewSecKey = _skycoin.SKY_cipher_NewSecKey +def SKY_coin_Block_Time(p0): + return _skycoin.SKY_coin_Block_Time(p0) +SKY_coin_Block_Time = _skycoin.SKY_coin_Block_Time -def SKY_cipher_SecKeyFromHex(p0, p1): - return _skycoin.SKY_cipher_SecKeyFromHex(p0, p1) -SKY_cipher_SecKeyFromHex = _skycoin.SKY_cipher_SecKeyFromHex +def SKY_coin_Block_Seq(p0): + return _skycoin.SKY_coin_Block_Seq(p0) +SKY_coin_Block_Seq = _skycoin.SKY_coin_Block_Seq -def SKY_cipher_SecKey_Verify(p0): - return _skycoin.SKY_cipher_SecKey_Verify(p0) -SKY_cipher_SecKey_Verify = _skycoin.SKY_cipher_SecKey_Verify +def SKY_coin_Block_HashBody(p0, p1): + return _skycoin.SKY_coin_Block_HashBody(p0, p1) +SKY_coin_Block_HashBody = _skycoin.SKY_coin_Block_HashBody -def SKY_cipher_SecKey_Hex(p0): - return _skycoin.SKY_cipher_SecKey_Hex(p0) -SKY_cipher_SecKey_Hex = _skycoin.SKY_cipher_SecKey_Hex +def SKY_coin_Block_Size(p0): + return _skycoin.SKY_coin_Block_Size(p0) +SKY_coin_Block_Size = _skycoin.SKY_coin_Block_Size + +def SKY_coin_Block_String(p0): + return _skycoin.SKY_coin_Block_String(p0) +SKY_coin_Block_String = _skycoin.SKY_coin_Block_String -def SKY_cipher_ECDH(p0, p1): - return _skycoin.SKY_cipher_ECDH(p0, p1) -SKY_cipher_ECDH = _skycoin.SKY_cipher_ECDH +def SKY_coin_Block_GetTransaction(p0, p1): + return _skycoin.SKY_coin_Block_GetTransaction(p0, p1) +SKY_coin_Block_GetTransaction = _skycoin.SKY_coin_Block_GetTransaction -def SKY_cipher_NewSig(p0, p1): - return _skycoin.SKY_cipher_NewSig(p0, p1) -SKY_cipher_NewSig = _skycoin.SKY_cipher_NewSig +def SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5): + return _skycoin.SKY_coin_NewBlockHeader(p0, p1, p2, p3, p4, p5) +SKY_coin_NewBlockHeader = _skycoin.SKY_coin_NewBlockHeader -def SKY_cipher_SigFromHex(p0, p1): - return _skycoin.SKY_cipher_SigFromHex(p0, p1) -SKY_cipher_SigFromHex = _skycoin.SKY_cipher_SigFromHex +def SKY_coin_BlockHeader_Hash(p0, p1): + return _skycoin.SKY_coin_BlockHeader_Hash(p0, p1) +SKY_coin_BlockHeader_Hash = _skycoin.SKY_coin_BlockHeader_Hash -def SKY_cipher_Sig_Hex(p0): - return _skycoin.SKY_cipher_Sig_Hex(p0) -SKY_cipher_Sig_Hex = _skycoin.SKY_cipher_Sig_Hex +def SKY_coin_BlockHeader_Bytes(p0): + return _skycoin.SKY_coin_BlockHeader_Bytes(p0) +SKY_coin_BlockHeader_Bytes = _skycoin.SKY_coin_BlockHeader_Bytes -def SKY_cipher_SignHash(p0, p1, p2): - return _skycoin.SKY_cipher_SignHash(p0, p1, p2) -SKY_cipher_SignHash = _skycoin.SKY_cipher_SignHash +def SKY_coin_BlockHeader_String(p0): + return _skycoin.SKY_coin_BlockHeader_String(p0) +SKY_coin_BlockHeader_String = _skycoin.SKY_coin_BlockHeader_String -def SKY_cipher_VerifyAddressSignedHash(p0, p1, p2): - return _skycoin.SKY_cipher_VerifyAddressSignedHash(p0, p1, p2) -SKY_cipher_VerifyAddressSignedHash = _skycoin.SKY_cipher_VerifyAddressSignedHash +def SKY_coin_BlockBody_Hash(p0, p1): + return _skycoin.SKY_coin_BlockBody_Hash(p0, p1) +SKY_coin_BlockBody_Hash = _skycoin.SKY_coin_BlockBody_Hash -def SKY_cipher_VerifySignedHash(p0, p1): - return _skycoin.SKY_cipher_VerifySignedHash(p0, p1) -SKY_cipher_VerifySignedHash = _skycoin.SKY_cipher_VerifySignedHash +def SKY_coin_BlockBody_Size(): + return _skycoin.SKY_coin_BlockBody_Size() +SKY_coin_BlockBody_Size = _skycoin.SKY_coin_BlockBody_Size -def SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2): - return _skycoin.SKY_cipher_VerifyPubKeySignedHash(p0, p1, p2) -SKY_cipher_VerifyPubKeySignedHash = _skycoin.SKY_cipher_VerifyPubKeySignedHash +def SKY_coin_BlockBody_Bytes(p0): + return _skycoin.SKY_coin_BlockBody_Bytes(p0) +SKY_coin_BlockBody_Bytes = _skycoin.SKY_coin_BlockBody_Bytes -def SKY_cipher_GenerateKeyPair(p0, p1): - return _skycoin.SKY_cipher_GenerateKeyPair(p0, p1) -SKY_cipher_GenerateKeyPair = _skycoin.SKY_cipher_GenerateKeyPair +def SKY_coin_CreateUnspents(*args): + return _skycoin.SKY_coin_CreateUnspents(*args) +SKY_coin_CreateUnspents = _skycoin.SKY_coin_CreateUnspents -def SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2): - return _skycoin.SKY_cipher_GenerateDeterministicKeyPair(p0, p1, p2) -SKY_cipher_GenerateDeterministicKeyPair = _skycoin.SKY_cipher_GenerateDeterministicKeyPair +def SKY_coin_CreateUnspent(p0, p1, p2, p3): + return _skycoin.SKY_coin_CreateUnspent(p0, p1, p2, p3) +SKY_coin_CreateUnspent = _skycoin.SKY_coin_CreateUnspent -def SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3): - return _skycoin.SKY_cipher_DeterministicKeyPairIterator(p0, p2, p3) -SKY_cipher_DeterministicKeyPairIterator = _skycoin.SKY_cipher_DeterministicKeyPairIterator +def SKY_coin_GetBlockObject(p0): + return _skycoin.SKY_coin_GetBlockObject(p0) +SKY_coin_GetBlockObject = _skycoin.SKY_coin_GetBlockObject -def SKY_cipher_GenerateDeterministicKeyPairs(*args): - return _skycoin.SKY_cipher_GenerateDeterministicKeyPairs(*args) -SKY_cipher_GenerateDeterministicKeyPairs = _skycoin.SKY_cipher_GenerateDeterministicKeyPairs +def SKY_coin_GetBlockBody(p0): + return _skycoin.SKY_coin_GetBlockBody(p0) +SKY_coin_GetBlockBody = _skycoin.SKY_coin_GetBlockBody -def SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1): - return _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed(p0, p1) -SKY_cipher_GenerateDeterministicKeyPairsSeed = _skycoin.SKY_cipher_GenerateDeterministicKeyPairsSeed +def SKY_coin_NewEmptyBlock(p0): + return _skycoin.SKY_coin_NewEmptyBlock(p0) +SKY_coin_NewEmptyBlock = _skycoin.SKY_coin_NewEmptyBlock -def SKY_cipher_CheckSecKey(p0): - return _skycoin.SKY_cipher_CheckSecKey(p0) -SKY_cipher_CheckSecKey = _skycoin.SKY_cipher_CheckSecKey +def SKY_wallet_NewError(p0): + return _skycoin.SKY_wallet_NewError(p0) +SKY_wallet_NewError = _skycoin.SKY_wallet_NewError -def SKY_cipher_CheckSecKeyHash(p0, p1): - return _skycoin.SKY_cipher_CheckSecKeyHash(p0, p1) -SKY_cipher_CheckSecKeyHash = _skycoin.SKY_cipher_CheckSecKeyHash +def SKY_wallet_NewWallet(p0, p1): + return _skycoin.SKY_wallet_NewWallet(p0, p1) +SKY_wallet_NewWallet = _skycoin.SKY_wallet_NewWallet -def SKY_droplet_FromString(p0): - return _skycoin.SKY_droplet_FromString(p0) -SKY_droplet_FromString = _skycoin.SKY_droplet_FromString +def SKY_wallet_Wallet_Lock(p0, p1, p2): + return _skycoin.SKY_wallet_Wallet_Lock(p0, p1, p2) +SKY_wallet_Wallet_Lock = _skycoin.SKY_wallet_Wallet_Lock -def SKY_droplet_ToString(p0): - return _skycoin.SKY_droplet_ToString(p0) -SKY_droplet_ToString = _skycoin.SKY_droplet_ToString +def SKY_wallet_Wallet_Unlock(p0, p1): + return _skycoin.SKY_wallet_Wallet_Unlock(p0, p1) +SKY_wallet_Wallet_Unlock = _skycoin.SKY_wallet_Wallet_Unlock -def SKY_handle_close(p0): - return _skycoin.SKY_handle_close(p0) -SKY_handle_close = _skycoin.SKY_handle_close +def SKY_wallet_Load(p0): + return _skycoin.SKY_wallet_Load(p0) +SKY_wallet_Load = _skycoin.SKY_wallet_Load -def SKY_handle_copy(p0): - return _skycoin.SKY_handle_copy(p0) -SKY_handle_copy = _skycoin.SKY_handle_copy +def SKY_wallet_Wallet_Save(p0, p1): + return _skycoin.SKY_wallet_Wallet_Save(p0, p1) +SKY_wallet_Wallet_Save = _skycoin.SKY_wallet_Wallet_Save -def SKY_fee_VerifyTransactionFee(p0, p1, p2): - return _skycoin.SKY_fee_VerifyTransactionFee(p0, p1, p2) -SKY_fee_VerifyTransactionFee = _skycoin.SKY_fee_VerifyTransactionFee +def SKY_wallet_Wallet_Validate(p0): + return _skycoin.SKY_wallet_Wallet_Validate(p0) +SKY_wallet_Wallet_Validate = _skycoin.SKY_wallet_Wallet_Validate -def SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2): - return _skycoin.SKY_fee_VerifyTransactionFeeForHours(p0, p1, p2) -SKY_fee_VerifyTransactionFeeForHours = _skycoin.SKY_fee_VerifyTransactionFeeForHours +def SKY_wallet_Wallet_Type(p0): + return _skycoin.SKY_wallet_Wallet_Type(p0) +SKY_wallet_Wallet_Type = _skycoin.SKY_wallet_Wallet_Type -def SKY_fee_RequiredFee(p0, p1): - return _skycoin.SKY_fee_RequiredFee(p0, p1) -SKY_fee_RequiredFee = _skycoin.SKY_fee_RequiredFee +def SKY_wallet_Wallet_Version(p0): + return _skycoin.SKY_wallet_Wallet_Version(p0) +SKY_wallet_Wallet_Version = _skycoin.SKY_wallet_Wallet_Version -def SKY_fee_RemainingHours(p0, p1): - return _skycoin.SKY_fee_RemainingHours(p0, p1) -SKY_fee_RemainingHours = _skycoin.SKY_fee_RemainingHours +def SKY_wallet_Wallet_Filename(p0): + return _skycoin.SKY_wallet_Wallet_Filename(p0) +SKY_wallet_Wallet_Filename = _skycoin.SKY_wallet_Wallet_Filename -def SKY_fee_TransactionFee(*args): - return _skycoin.SKY_fee_TransactionFee(*args) -SKY_fee_TransactionFee = _skycoin.SKY_fee_TransactionFee +def SKY_wallet_Wallet_Label(p0): + return _skycoin.SKY_wallet_Wallet_Label(p0) +SKY_wallet_Wallet_Label = _skycoin.SKY_wallet_Wallet_Label -def SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2): - return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt(p0, p1, p2) -SKY_encrypt_ScryptChacha20poly1305_Encrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Encrypt +def SKY_wallet_Wallet_IsEncrypted(p0): + return _skycoin.SKY_wallet_Wallet_IsEncrypted(p0) +SKY_wallet_Wallet_IsEncrypted = _skycoin.SKY_wallet_Wallet_IsEncrypted -def SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2): - return _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt(p0, p1, p2) -SKY_encrypt_ScryptChacha20poly1305_Decrypt = _skycoin.SKY_encrypt_ScryptChacha20poly1305_Decrypt +def SKY_wallet_Wallet_GenerateAddresses(p0, p1): + return _skycoin.SKY_wallet_Wallet_GenerateAddresses(p0, p1) +SKY_wallet_Wallet_GenerateAddresses = _skycoin.SKY_wallet_Wallet_GenerateAddresses -def SKY_api_NewClient(p0): - return _skycoin.SKY_api_NewClient(p0) -SKY_api_NewClient = _skycoin.SKY_api_NewClient +def SKY_wallet_Wallet_GetAddresses(p0): + return _skycoin.SKY_wallet_Wallet_GetAddresses(p0) +SKY_wallet_Wallet_GetAddresses = _skycoin.SKY_wallet_Wallet_GetAddresses -def SKY_api_Client_CSRF(p0): - return _skycoin.SKY_api_Client_CSRF(p0) -SKY_api_Client_CSRF = _skycoin.SKY_api_Client_CSRF +def SKY_wallet_Wallet_GetEntry(p0, p1, p2): + return _skycoin.SKY_wallet_Wallet_GetEntry(p0, p1, p2) +SKY_wallet_Wallet_GetEntry = _skycoin.SKY_wallet_Wallet_GetEntry -def SKY_api_Client_Version(p0): - return _skycoin.SKY_api_Client_Version(p0) -SKY_api_Client_Version = _skycoin.SKY_api_Client_Version +def SKY_wallet_Wallet_AddEntry(p0, p1): + return _skycoin.SKY_wallet_Wallet_AddEntry(p0, p1) +SKY_wallet_Wallet_AddEntry = _skycoin.SKY_wallet_Wallet_AddEntry -def SKY_api_Client_Outputs(p0): - return _skycoin.SKY_api_Client_Outputs(p0) -SKY_api_Client_Outputs = _skycoin.SKY_api_Client_Outputs +def SKY_wallet_DistributeSpendHours(p0, p1, p2): + return _skycoin.SKY_wallet_DistributeSpendHours(p0, p1, p2) +SKY_wallet_DistributeSpendHours = _skycoin.SKY_wallet_DistributeSpendHours -def SKY_api_Client_OutputsForAddresses(p0, p1): - return _skycoin.SKY_api_Client_OutputsForAddresses(p0, p1) -SKY_api_Client_OutputsForAddresses = _skycoin.SKY_api_Client_OutputsForAddresses +def SKY_wallet_DistributeCoinHoursProportional(p0, p1): + return _skycoin.SKY_wallet_DistributeCoinHoursProportional(p0, p1) +SKY_wallet_DistributeCoinHoursProportional = _skycoin.SKY_wallet_DistributeCoinHoursProportional -def SKY_api_Client_OutputsForHashes(p0, p1): - return _skycoin.SKY_api_Client_OutputsForHashes(p0, p1) -SKY_api_Client_OutputsForHashes = _skycoin.SKY_api_Client_OutputsForHashes +def SKY_wallet_NewUxBalances(p0): + return _skycoin.SKY_wallet_NewUxBalances(p0) +SKY_wallet_NewUxBalances = _skycoin.SKY_wallet_NewUxBalances -def SKY_api_Client_CoinSupply(p0): - return _skycoin.SKY_api_Client_CoinSupply(p0) -SKY_api_Client_CoinSupply = _skycoin.SKY_api_Client_CoinSupply +def SKY_wallet_NewUxBalance(p0, p1, p2): + return _skycoin.SKY_wallet_NewUxBalance(p0, p1, p2) +SKY_wallet_NewUxBalance = _skycoin.SKY_wallet_NewUxBalance -def SKY_api_Client_BlockByHash(p0, p1): - return _skycoin.SKY_api_Client_BlockByHash(p0, p1) -SKY_api_Client_BlockByHash = _skycoin.SKY_api_Client_BlockByHash +def SKY_wallet_ChooseSpendsMinimizeUxOuts(p0, p1, p2): + return _skycoin.SKY_wallet_ChooseSpendsMinimizeUxOuts(p0, p1, p2) +SKY_wallet_ChooseSpendsMinimizeUxOuts = _skycoin.SKY_wallet_ChooseSpendsMinimizeUxOuts -def SKY_api_Client_BlockBySeq(p0, p1): - return _skycoin.SKY_api_Client_BlockBySeq(p0, p1) -SKY_api_Client_BlockBySeq = _skycoin.SKY_api_Client_BlockBySeq +def SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2): + return _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2) +SKY_wallet_ChooseSpendsMaximizeUxOuts = _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts -def SKY_api_Client_Blocks(p0, p1): - return _skycoin.SKY_api_Client_Blocks(p0, p1) -SKY_api_Client_Blocks = _skycoin.SKY_api_Client_Blocks +def SKY_cli_GetWalletOutputsFromFile(p0, p1, p2): + return _skycoin.SKY_cli_GetWalletOutputsFromFile(p0, p1, p2) +SKY_cli_GetWalletOutputsFromFile = _skycoin.SKY_cli_GetWalletOutputsFromFile -def SKY_api_Client_LastBlocks(p0, p1): - return _skycoin.SKY_api_Client_LastBlocks(p0, p1) -SKY_api_Client_LastBlocks = _skycoin.SKY_api_Client_LastBlocks +def SKY_cli_GetWalletOutputs(p0, p2): + return _skycoin.SKY_cli_GetWalletOutputs(p0, p2) +SKY_cli_GetWalletOutputs = _skycoin.SKY_cli_GetWalletOutputs -def SKY_api_Client_BlockchainMetadata(p0): - return _skycoin.SKY_api_Client_BlockchainMetadata(p0) -SKY_api_Client_BlockchainMetadata = _skycoin.SKY_api_Client_BlockchainMetadata +def SKY_cipher_DecodeBase58Address(p0, p1): + return _skycoin.SKY_cipher_DecodeBase58Address(p0, p1) +SKY_cipher_DecodeBase58Address = _skycoin.SKY_cipher_DecodeBase58Address -def SKY_api_Client_BlockchainProgress(p0): - return _skycoin.SKY_api_Client_BlockchainProgress(p0) -SKY_api_Client_BlockchainProgress = _skycoin.SKY_api_Client_BlockchainProgress +def SKY_cipher_AddressFromBytes(p0, p1): + return _skycoin.SKY_cipher_AddressFromBytes(p0, p1) +SKY_cipher_AddressFromBytes = _skycoin.SKY_cipher_AddressFromBytes -def SKY_api_Client_Balance(p0, p1, p2): - return _skycoin.SKY_api_Client_Balance(p0, p1, p2) -SKY_api_Client_Balance = _skycoin.SKY_api_Client_Balance +def SKY_cipher_AddressFromPubKey(p0, p1): + return _skycoin.SKY_cipher_AddressFromPubKey(p0, p1) +SKY_cipher_AddressFromPubKey = _skycoin.SKY_cipher_AddressFromPubKey -def SKY_api_Client_UxOut(p0, p1): - return _skycoin.SKY_api_Client_UxOut(p0, p1) -SKY_api_Client_UxOut = _skycoin.SKY_api_Client_UxOut +def SKY_cipher_AddressFromSecKey(p0, p1): + return _skycoin.SKY_cipher_AddressFromSecKey(p0, p1) +SKY_cipher_AddressFromSecKey = _skycoin.SKY_cipher_AddressFromSecKey -def SKY_api_Client_AddressUxOuts(p0, p1): - return _skycoin.SKY_api_Client_AddressUxOuts(p0, p1) -SKY_api_Client_AddressUxOuts = _skycoin.SKY_api_Client_AddressUxOuts +def SKY_cipher_Address_Null(p0): + return _skycoin.SKY_cipher_Address_Null(p0) +SKY_cipher_Address_Null = _skycoin.SKY_cipher_Address_Null + +def SKY_cipher_Address_Bytes(p0): + return _skycoin.SKY_cipher_Address_Bytes(p0) +SKY_cipher_Address_Bytes = _skycoin.SKY_cipher_Address_Bytes -def SKY_api_Client_Wallet(p0, p1): - return _skycoin.SKY_api_Client_Wallet(p0, p1) -SKY_api_Client_Wallet = _skycoin.SKY_api_Client_Wallet +def SKY_cipher_Address_Verify(p0, p1): + return _skycoin.SKY_cipher_Address_Verify(p0, p1) +SKY_cipher_Address_Verify = _skycoin.SKY_cipher_Address_Verify -def SKY_api_Client_Wallets(p0): - return _skycoin.SKY_api_Client_Wallets(p0) -SKY_api_Client_Wallets = _skycoin.SKY_api_Client_Wallets +def SKY_cipher_Address_String(p0): + return _skycoin.SKY_cipher_Address_String(p0) +SKY_cipher_Address_String = _skycoin.SKY_cipher_Address_String -def SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3): - return _skycoin.SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3) -SKY_api_Client_CreateUnencryptedWallet = _skycoin.SKY_api_Client_CreateUnencryptedWallet +def SKY_cipher_Address_Checksum(p0, p1): + return _skycoin.SKY_cipher_Address_Checksum(p0, p1) +SKY_cipher_Address_Checksum = _skycoin.SKY_cipher_Address_Checksum -def SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4): - return _skycoin.SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4) -SKY_api_Client_CreateEncryptedWallet = _skycoin.SKY_api_Client_CreateEncryptedWallet +def SKY_coin_AddUint64(p0, p1): + return _skycoin.SKY_coin_AddUint64(p0, p1) +SKY_coin_AddUint64 = _skycoin.SKY_coin_AddUint64 -def SKY_api_Client_NewWalletAddress(p0, p1, p2, p3): - return _skycoin.SKY_api_Client_NewWalletAddress(p0, p1, p2, p3) -SKY_api_Client_NewWalletAddress = _skycoin.SKY_api_Client_NewWalletAddress +def SKY_coin_Uint64ToInt64(p0): + return _skycoin.SKY_coin_Uint64ToInt64(p0) +SKY_coin_Uint64ToInt64 = _skycoin.SKY_coin_Uint64ToInt64 -def SKY_api_Client_WalletBalance(p0, p1, p2): - return _skycoin.SKY_api_Client_WalletBalance(p0, p1, p2) -SKY_api_Client_WalletBalance = _skycoin.SKY_api_Client_WalletBalance +def SKY_coin_Int64ToUint64(p0): + return _skycoin.SKY_coin_Int64ToUint64(p0) +SKY_coin_Int64ToUint64 = _skycoin.SKY_coin_Int64ToUint64 -def SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5): - return _skycoin.SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5) -SKY_api_Client_Spend = _skycoin.SKY_api_Client_Spend +def SKY_coin_IntToUint32(p0): + return _skycoin.SKY_coin_IntToUint32(p0) +SKY_coin_IntToUint32 = _skycoin.SKY_coin_IntToUint32 -def SKY_api_Client_CreateTransaction(p0): - return _skycoin.SKY_api_Client_CreateTransaction(p0) -SKY_api_Client_CreateTransaction = _skycoin.SKY_api_Client_CreateTransaction +def SKY_map_Get(p1): + return _skycoin.SKY_map_Get(p1) +SKY_map_Get = _skycoin.SKY_map_Get -def SKY_api_Client_UpdateWallet(p0, p1, p2): - return _skycoin.SKY_api_Client_UpdateWallet(p0, p1, p2) -SKY_api_Client_UpdateWallet = _skycoin.SKY_api_Client_UpdateWallet +def SKY_map_HasKey(p1): + return _skycoin.SKY_map_HasKey(p1) +SKY_map_HasKey = _skycoin.SKY_map_HasKey -def SKY_api_Client_WalletFolderName(p0): - return _skycoin.SKY_api_Client_WalletFolderName(p0) -SKY_api_Client_WalletFolderName = _skycoin.SKY_api_Client_WalletFolderName +def SKY_map_Close(): + return _skycoin.SKY_map_Close() +SKY_map_Close = _skycoin.SKY_map_Close -def SKY_api_Client_NewSeed(p0, p1): - return _skycoin.SKY_api_Client_NewSeed(p0, p1) -SKY_api_Client_NewSeed = _skycoin.SKY_api_Client_NewSeed +def SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4): + return _skycoin.SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4) +SKY_cli_CreateRawTxFromWallet = _skycoin.SKY_cli_CreateRawTxFromWallet -def SKY_api_Client_WalletSeed(p0, p1, p2): - return _skycoin.SKY_api_Client_WalletSeed(p0, p1, p2) -SKY_api_Client_WalletSeed = _skycoin.SKY_api_Client_WalletSeed +def SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5): + return _skycoin.SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5) +SKY_cli_CreateRawTxFromAddress = _skycoin.SKY_cli_CreateRawTxFromAddress -def SKY_api_Client_NetworkConnection(p0, p1): - return _skycoin.SKY_api_Client_NetworkConnection(p0, p1) -SKY_api_Client_NetworkConnection = _skycoin.SKY_api_Client_NetworkConnection +def SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5): + return _skycoin.SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5) +SKY_cli_CreateRawTx = _skycoin.SKY_cli_CreateRawTx -def SKY_api_Client_NetworkConnections(p0, p1): - return _skycoin.SKY_api_Client_NetworkConnections(p0, p1) -SKY_api_Client_NetworkConnections = _skycoin.SKY_api_Client_NetworkConnections +def SKY_cli_NewTransaction(p0, p1, p2): + return _skycoin.SKY_cli_NewTransaction(p0, p1, p2) +SKY_cli_NewTransaction = _skycoin.SKY_cli_NewTransaction -def SKY_api_Client_NetworkDefaultPeers(p0): - return _skycoin.SKY_api_Client_NetworkDefaultPeers(p0) -SKY_api_Client_NetworkDefaultPeers = _skycoin.SKY_api_Client_NetworkDefaultPeers +def SKY_file_InitDataDir(p0): + return _skycoin.SKY_file_InitDataDir(p0) +SKY_file_InitDataDir = _skycoin.SKY_file_InitDataDir -def SKY_api_Client_NetworkTrustedPeers(p0): - return _skycoin.SKY_api_Client_NetworkTrustedPeers(p0) -SKY_api_Client_NetworkTrustedPeers = _skycoin.SKY_api_Client_NetworkTrustedPeers +def SKY_file_UserHome(): + return _skycoin.SKY_file_UserHome() +SKY_file_UserHome = _skycoin.SKY_file_UserHome -def SKY_api_Client_NetworkExchangedPeers(p0): - return _skycoin.SKY_api_Client_NetworkExchangedPeers(p0) -SKY_api_Client_NetworkExchangedPeers = _skycoin.SKY_api_Client_NetworkExchangedPeers +def SKY_file_ResolveResourceDirectory(p0): + return _skycoin.SKY_file_ResolveResourceDirectory(p0) +SKY_file_ResolveResourceDirectory = _skycoin.SKY_file_ResolveResourceDirectory -def SKY_api_Client_PendingTransactions(p0): - return _skycoin.SKY_api_Client_PendingTransactions(p0) -SKY_api_Client_PendingTransactions = _skycoin.SKY_api_Client_PendingTransactions +def SKY_file_DetermineResourcePath(p0, p1, p2): + return _skycoin.SKY_file_DetermineResourcePath(p0, p1, p2) +SKY_file_DetermineResourcePath = _skycoin.SKY_file_DetermineResourcePath -def SKY_api_Client_Transaction(p0, p1): - return _skycoin.SKY_api_Client_Transaction(p0, p1) -SKY_api_Client_Transaction = _skycoin.SKY_api_Client_Transaction +def SKY_api_NewWalletResponse(p0): + return _skycoin.SKY_api_NewWalletResponse(p0) +SKY_api_NewWalletResponse = _skycoin.SKY_api_NewWalletResponse -def SKY_api_Client_Transactions(p0, p1): - return _skycoin.SKY_api_Client_Transactions(p0, p1) -SKY_api_Client_Transactions = _skycoin.SKY_api_Client_Transactions +def SKY_wallet_CryptoTypeFromString(p0): + return _skycoin.SKY_wallet_CryptoTypeFromString(p0) +SKY_wallet_CryptoTypeFromString = _skycoin.SKY_wallet_CryptoTypeFromString -def SKY_api_Client_ConfirmedTransactions(p0, p1): - return _skycoin.SKY_api_Client_ConfirmedTransactions(p0, p1) -SKY_api_Client_ConfirmedTransactions = _skycoin.SKY_api_Client_ConfirmedTransactions +def SKY_wallet_Entry_Verify(p0): + return _skycoin.SKY_wallet_Entry_Verify(p0) +SKY_wallet_Entry_Verify = _skycoin.SKY_wallet_Entry_Verify -def SKY_api_Client_UnconfirmedTransactions(p0, p1): - return _skycoin.SKY_api_Client_UnconfirmedTransactions(p0, p1) -SKY_api_Client_UnconfirmedTransactions = _skycoin.SKY_api_Client_UnconfirmedTransactions +def SKY_wallet_Entry_VerifyPublic(p0): + return _skycoin.SKY_wallet_Entry_VerifyPublic(p0) +SKY_wallet_Entry_VerifyPublic = _skycoin.SKY_wallet_Entry_VerifyPublic -def SKY_api_Client_InjectTransaction(p0, p1): - return _skycoin.SKY_api_Client_InjectTransaction(p0, p1) -SKY_api_Client_InjectTransaction = _skycoin.SKY_api_Client_InjectTransaction +def SKY_bip39_NewDefaultMnemomic(): + return _skycoin.SKY_bip39_NewDefaultMnemomic() +SKY_bip39_NewDefaultMnemomic = _skycoin.SKY_bip39_NewDefaultMnemomic -def SKY_api_Client_ResendUnconfirmedTransactions(p0): - return _skycoin.SKY_api_Client_ResendUnconfirmedTransactions(p0) -SKY_api_Client_ResendUnconfirmedTransactions = _skycoin.SKY_api_Client_ResendUnconfirmedTransactions +def SKY_bip39_NewEntropy(p0): + return _skycoin.SKY_bip39_NewEntropy(p0) +SKY_bip39_NewEntropy = _skycoin.SKY_bip39_NewEntropy -def SKY_api_Client_RawTransaction(p0, p1): - return _skycoin.SKY_api_Client_RawTransaction(p0, p1) -SKY_api_Client_RawTransaction = _skycoin.SKY_api_Client_RawTransaction +def SKY_bip39_NewMnemonic(p0): + return _skycoin.SKY_bip39_NewMnemonic(p0) +SKY_bip39_NewMnemonic = _skycoin.SKY_bip39_NewMnemonic -def SKY_api_Client_AddressTransactions(p0, p1): - return _skycoin.SKY_api_Client_AddressTransactions(p0, p1) -SKY_api_Client_AddressTransactions = _skycoin.SKY_api_Client_AddressTransactions +def SKY_bip39_MnemonicToByteArray(p0): + return _skycoin.SKY_bip39_MnemonicToByteArray(p0) +SKY_bip39_MnemonicToByteArray = _skycoin.SKY_bip39_MnemonicToByteArray -def SKY_api_Client_Richlist(p0, p1): - return _skycoin.SKY_api_Client_Richlist(p0, p1) -SKY_api_Client_Richlist = _skycoin.SKY_api_Client_Richlist +def SKY_bip39_IsMnemonicValid(p0): + return _skycoin.SKY_bip39_IsMnemonicValid(p0) +SKY_bip39_IsMnemonicValid = _skycoin.SKY_bip39_IsMnemonicValid -def SKY_api_Client_AddressCount(p0): - return _skycoin.SKY_api_Client_AddressCount(p0) -SKY_api_Client_AddressCount = _skycoin.SKY_api_Client_AddressCount +def SKY_httphelper_Address_UnmarshalJSON(p0, p1): + return _skycoin.SKY_httphelper_Address_UnmarshalJSON(p0, p1) +SKY_httphelper_Address_UnmarshalJSON = _skycoin.SKY_httphelper_Address_UnmarshalJSON -def SKY_api_Client_UnloadWallet(p0, p1): - return _skycoin.SKY_api_Client_UnloadWallet(p0, p1) -SKY_api_Client_UnloadWallet = _skycoin.SKY_api_Client_UnloadWallet +def SKY_httphelper_Address_MarshalJSON(p0): + return _skycoin.SKY_httphelper_Address_MarshalJSON(p0) +SKY_httphelper_Address_MarshalJSON = _skycoin.SKY_httphelper_Address_MarshalJSON -def SKY_api_Client_Health(p0): - return _skycoin.SKY_api_Client_Health(p0) -SKY_api_Client_Health = _skycoin.SKY_api_Client_Health +def SKY_httphelper_Coins_UnmarshalJSON(p1): + return _skycoin.SKY_httphelper_Coins_UnmarshalJSON(p1) +SKY_httphelper_Coins_UnmarshalJSON = _skycoin.SKY_httphelper_Coins_UnmarshalJSON -def SKY_api_Client_EncryptWallet(p0, p1, p2): - return _skycoin.SKY_api_Client_EncryptWallet(p0, p1, p2) -SKY_api_Client_EncryptWallet = _skycoin.SKY_api_Client_EncryptWallet +def SKY_httphelper_Coins_MarshalJSON(): + return _skycoin.SKY_httphelper_Coins_MarshalJSON() +SKY_httphelper_Coins_MarshalJSON = _skycoin.SKY_httphelper_Coins_MarshalJSON -def SKY_api_Client_DecryptWallet(p0, p1, p2): - return _skycoin.SKY_api_Client_DecryptWallet(p0, p1, p2) -SKY_api_Client_DecryptWallet = _skycoin.SKY_api_Client_DecryptWallet +def SKY_httphelper_Coins_Value(): + return _skycoin.SKY_httphelper_Coins_Value() +SKY_httphelper_Coins_Value = _skycoin.SKY_httphelper_Coins_Value -def SKY_map_Get(p1): - return _skycoin.SKY_map_Get(p1) -SKY_map_Get = _skycoin.SKY_map_Get +def SKY_httphelper_Hours_UnmarshalJSON(p1): + return _skycoin.SKY_httphelper_Hours_UnmarshalJSON(p1) +SKY_httphelper_Hours_UnmarshalJSON = _skycoin.SKY_httphelper_Hours_UnmarshalJSON -def SKY_map_HasKey(p1): - return _skycoin.SKY_map_HasKey(p1) -SKY_map_HasKey = _skycoin.SKY_map_HasKey +def SKY_httphelper_Hours_MarshalJSON(): + return _skycoin.SKY_httphelper_Hours_MarshalJSON() +SKY_httphelper_Hours_MarshalJSON = _skycoin.SKY_httphelper_Hours_MarshalJSON -def SKY_map_Close(): - return _skycoin.SKY_map_Close() -SKY_map_Close = _skycoin.SKY_map_Close +def SKY_httphelper_Hours_Value(): + return _skycoin.SKY_httphelper_Hours_Value() +SKY_httphelper_Hours_Value = _skycoin.SKY_httphelper_Hours_Value -def SKY_wallet_NewError(p0): - return _skycoin.SKY_wallet_NewError(p0) -SKY_wallet_NewError = _skycoin.SKY_wallet_NewError +def SKY_webrpc_NewClient(p0): + return _skycoin.SKY_webrpc_NewClient(p0) +SKY_webrpc_NewClient = _skycoin.SKY_webrpc_NewClient -def SKY_wallet_NewWallet(p0, p1): - return _skycoin.SKY_wallet_NewWallet(p0, p1) -SKY_wallet_NewWallet = _skycoin.SKY_wallet_NewWallet +def SKY_webrpc_Client_CSRF(p0): + return _skycoin.SKY_webrpc_Client_CSRF(p0) +SKY_webrpc_Client_CSRF = _skycoin.SKY_webrpc_Client_CSRF -def SKY_wallet_Wallet_Lock(p0, p1, p2): - return _skycoin.SKY_wallet_Wallet_Lock(p0, p1, p2) -SKY_wallet_Wallet_Lock = _skycoin.SKY_wallet_Wallet_Lock +def SKY_webrpc_Client_InjectTransaction(p0, p1): + return _skycoin.SKY_webrpc_Client_InjectTransaction(p0, p1) +SKY_webrpc_Client_InjectTransaction = _skycoin.SKY_webrpc_Client_InjectTransaction -def SKY_wallet_Wallet_Unlock(p0, p1): - return _skycoin.SKY_wallet_Wallet_Unlock(p0, p1) -SKY_wallet_Wallet_Unlock = _skycoin.SKY_wallet_Wallet_Unlock +def SKY_webrpc_Client_GetStatus(p0, p1): + return _skycoin.SKY_webrpc_Client_GetStatus(p0, p1) +SKY_webrpc_Client_GetStatus = _skycoin.SKY_webrpc_Client_GetStatus -def SKY_wallet_Load(p0): - return _skycoin.SKY_wallet_Load(p0) -SKY_wallet_Load = _skycoin.SKY_wallet_Load +def SKY_webrpc_Client_GetTransactionByID(p0, p1, p2): + return _skycoin.SKY_webrpc_Client_GetTransactionByID(p0, p1, p2) +SKY_webrpc_Client_GetTransactionByID = _skycoin.SKY_webrpc_Client_GetTransactionByID -def SKY_wallet_Wallet_Save(p0, p1): - return _skycoin.SKY_wallet_Wallet_Save(p0, p1) -SKY_wallet_Wallet_Save = _skycoin.SKY_wallet_Wallet_Save +def SKY_webrpc_Client_GetAddressUxOuts(p0, p1): + return _skycoin.SKY_webrpc_Client_GetAddressUxOuts(p0, p1) +SKY_webrpc_Client_GetAddressUxOuts = _skycoin.SKY_webrpc_Client_GetAddressUxOuts -def SKY_wallet_Wallet_Validate(p0): - return _skycoin.SKY_wallet_Wallet_Validate(p0) -SKY_wallet_Wallet_Validate = _skycoin.SKY_wallet_Wallet_Validate +def SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2): + return _skycoin.SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2) +SKY_webrpc_Client_GetBlocksInRange = _skycoin.SKY_webrpc_Client_GetBlocksInRange + +def SKY_webrpc_Client_GetBlocksBySeq(p0, p1): + return _skycoin.SKY_webrpc_Client_GetBlocksBySeq(p0, p1) +SKY_webrpc_Client_GetBlocksBySeq = _skycoin.SKY_webrpc_Client_GetBlocksBySeq -def SKY_wallet_Wallet_Type(p0): - return _skycoin.SKY_wallet_Wallet_Type(p0) -SKY_wallet_Wallet_Type = _skycoin.SKY_wallet_Wallet_Type +def SKY_webrpc_Client_GetLastBlocks(p0, p1): + return _skycoin.SKY_webrpc_Client_GetLastBlocks(p0, p1) +SKY_webrpc_Client_GetLastBlocks = _skycoin.SKY_webrpc_Client_GetLastBlocks -def SKY_wallet_Wallet_Version(p0): - return _skycoin.SKY_wallet_Wallet_Version(p0) -SKY_wallet_Wallet_Version = _skycoin.SKY_wallet_Wallet_Version +def SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6): + return _skycoin.SKY_wallet_CreateOptionsHandle(p0, p1, p2, p3, p4, p5, p6) +SKY_wallet_CreateOptionsHandle = _skycoin.SKY_wallet_CreateOptionsHandle -def SKY_wallet_Wallet_Filename(p0): - return _skycoin.SKY_wallet_Wallet_Filename(p0) -SKY_wallet_Wallet_Filename = _skycoin.SKY_wallet_Wallet_Filename +def SKY_cli_App_Run(p0, p1): + return _skycoin.SKY_cli_App_Run(p0, p1) +SKY_cli_App_Run = _skycoin.SKY_cli_App_Run -def SKY_wallet_Wallet_Label(p0): - return _skycoin.SKY_wallet_Wallet_Label(p0) -SKY_wallet_Wallet_Label = _skycoin.SKY_wallet_Wallet_Label +def SKY_cli_Config_GetCoin(p0): + return _skycoin.SKY_cli_Config_GetCoin(p0) +SKY_cli_Config_GetCoin = _skycoin.SKY_cli_Config_GetCoin -def SKY_wallet_Wallet_IsEncrypted(p0): - return _skycoin.SKY_wallet_Wallet_IsEncrypted(p0) -SKY_wallet_Wallet_IsEncrypted = _skycoin.SKY_wallet_Wallet_IsEncrypted +def SKY_cli_Config_GetRPCAddress(p0): + return _skycoin.SKY_cli_Config_GetRPCAddress(p0) +SKY_cli_Config_GetRPCAddress = _skycoin.SKY_cli_Config_GetRPCAddress -def SKY_wallet_Wallet_GenerateAddresses(p0, p1): - return _skycoin.SKY_wallet_Wallet_GenerateAddresses(p0, p1) -SKY_wallet_Wallet_GenerateAddresses = _skycoin.SKY_wallet_Wallet_GenerateAddresses +def SKY_cli_RPCClientFromApp(p0): + return _skycoin.SKY_cli_RPCClientFromApp(p0) +SKY_cli_RPCClientFromApp = _skycoin.SKY_cli_RPCClientFromApp -def SKY_wallet_Wallet_GetAddresses(p0): - return _skycoin.SKY_wallet_Wallet_GetAddresses(p0) -SKY_wallet_Wallet_GetAddresses = _skycoin.SKY_wallet_Wallet_GetAddresses +def SKY_cli_Getenv(p0): + return _skycoin.SKY_cli_Getenv(p0) +SKY_cli_Getenv = _skycoin.SKY_cli_Getenv -def SKY_wallet_Wallet_GetEntry(p0, p1, p2): - return _skycoin.SKY_wallet_Wallet_GetEntry(p0, p1, p2) -SKY_wallet_Wallet_GetEntry = _skycoin.SKY_wallet_Wallet_GetEntry +def SKY_cli_Setenv(p0, p1): + return _skycoin.SKY_cli_Setenv(p0, p1) +SKY_cli_Setenv = _skycoin.SKY_cli_Setenv -def SKY_wallet_Wallet_AddEntry(p0, p1): - return _skycoin.SKY_wallet_Wallet_AddEntry(p0, p1) -SKY_wallet_Wallet_AddEntry = _skycoin.SKY_wallet_Wallet_AddEntry +def SKY_wallet_NewBalance(p0, p1, p2): + return _skycoin.SKY_wallet_NewBalance(p0, p1, p2) +SKY_wallet_NewBalance = _skycoin.SKY_wallet_NewBalance -def SKY_wallet_DistributeSpendHours(p0, p1, p2): - return _skycoin.SKY_wallet_DistributeSpendHours(p0, p1, p2) -SKY_wallet_DistributeSpendHours = _skycoin.SKY_wallet_DistributeSpendHours +def SKY_wallet_NewBalanceFromUxOut(p0, p1, p2): + return _skycoin.SKY_wallet_NewBalanceFromUxOut(p0, p1, p2) +SKY_wallet_NewBalanceFromUxOut = _skycoin.SKY_wallet_NewBalanceFromUxOut -def SKY_wallet_DistributeCoinHoursProportional(p0, p1): - return _skycoin.SKY_wallet_DistributeCoinHoursProportional(p0, p1) -SKY_wallet_DistributeCoinHoursProportional = _skycoin.SKY_wallet_DistributeCoinHoursProportional +def SKY_wallet_Balance_Add(p0, p1, p2): + return _skycoin.SKY_wallet_Balance_Add(p0, p1, p2) +SKY_wallet_Balance_Add = _skycoin.SKY_wallet_Balance_Add -def SKY_wallet_NewUxBalances(p0): - return _skycoin.SKY_wallet_NewUxBalances(p0) -SKY_wallet_NewUxBalances = _skycoin.SKY_wallet_NewUxBalances +def SKY_wallet_Balance_Sub(p0, p1, p2): + return _skycoin.SKY_wallet_Balance_Sub(p0, p1, p2) +SKY_wallet_Balance_Sub = _skycoin.SKY_wallet_Balance_Sub -def SKY_wallet_NewUxBalance(p0, p1, p2): - return _skycoin.SKY_wallet_NewUxBalance(p0, p1, p2) -SKY_wallet_NewUxBalance = _skycoin.SKY_wallet_NewUxBalance +def SKY_wallet_Balance_Equals(p0, p1): + return _skycoin.SKY_wallet_Balance_Equals(p0, p1) +SKY_wallet_Balance_Equals = _skycoin.SKY_wallet_Balance_Equals -def SKY_wallet_ChooseSpendsMinimizeUxOuts(p0, p1, p2): - return _skycoin.SKY_wallet_ChooseSpendsMinimizeUxOuts(p0, p1, p2) -SKY_wallet_ChooseSpendsMinimizeUxOuts = _skycoin.SKY_wallet_ChooseSpendsMinimizeUxOuts +def SKY_wallet_Balance_IsZero(p0): + return _skycoin.SKY_wallet_Balance_IsZero(p0) +SKY_wallet_Balance_IsZero = _skycoin.SKY_wallet_Balance_IsZero -def SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2): - return _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts(p0, p1, p2) -SKY_wallet_ChooseSpendsMaximizeUxOuts = _skycoin.SKY_wallet_ChooseSpendsMaximizeUxOuts +def SKY_droplet_FromString(p0): + return _skycoin.SKY_droplet_FromString(p0) +SKY_droplet_FromString = _skycoin.SKY_droplet_FromString -def SKY_cipher_DecodeBase58BitcoinAddress(p0, p1): - return _skycoin.SKY_cipher_DecodeBase58BitcoinAddress(p0, p1) -SKY_cipher_DecodeBase58BitcoinAddress = _skycoin.SKY_cipher_DecodeBase58BitcoinAddress +def SKY_droplet_ToString(p0): + return _skycoin.SKY_droplet_ToString(p0) +SKY_droplet_ToString = _skycoin.SKY_droplet_ToString -def SKY_cipher_BitcoinAddressFromPubKey(p0, p1): - return _skycoin.SKY_cipher_BitcoinAddressFromPubKey(p0, p1) -SKY_cipher_BitcoinAddressFromPubKey = _skycoin.SKY_cipher_BitcoinAddressFromPubKey +def SKY_wallet_NewReadableEntry(p0, p1): + return _skycoin.SKY_wallet_NewReadableEntry(p0, p1) +SKY_wallet_NewReadableEntry = _skycoin.SKY_wallet_NewReadableEntry -def SKY_cipher_BitcoinAddressFromSecKey(p0, p1): - return _skycoin.SKY_cipher_BitcoinAddressFromSecKey(p0, p1) -SKY_cipher_BitcoinAddressFromSecKey = _skycoin.SKY_cipher_BitcoinAddressFromSecKey +def SKY_wallet_LoadReadableWallet(p0): + return _skycoin.SKY_wallet_LoadReadableWallet(p0) +SKY_wallet_LoadReadableWallet = _skycoin.SKY_wallet_LoadReadableWallet -def SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0): - return _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey(p0) -SKY_cipher_BitcoinWalletImportFormatFromSeckey = _skycoin.SKY_cipher_BitcoinWalletImportFormatFromSeckey +def SKY_wallet_ReadableWallet_Save(p0, p1): + return _skycoin.SKY_wallet_ReadableWallet_Save(p0, p1) +SKY_wallet_ReadableWallet_Save = _skycoin.SKY_wallet_ReadableWallet_Save -def SKY_cipher_BitcoinAddressFromBytes(p0, p1): - return _skycoin.SKY_cipher_BitcoinAddressFromBytes(p0, p1) -SKY_cipher_BitcoinAddressFromBytes = _skycoin.SKY_cipher_BitcoinAddressFromBytes +def SKY_wallet_ReadableWallet_Load(p0, p1): + return _skycoin.SKY_wallet_ReadableWallet_Load(p0, p1) +SKY_wallet_ReadableWallet_Load = _skycoin.SKY_wallet_ReadableWallet_Load -def SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1): - return _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat(p0, p1) -SKY_cipher_SecKeyFromBitcoinWalletImportFormat = _skycoin.SKY_cipher_SecKeyFromBitcoinWalletImportFormat +def SKY_wallet_ReadableWallet_Erase(p0): + return _skycoin.SKY_wallet_ReadableWallet_Erase(p0) +SKY_wallet_ReadableWallet_Erase = _skycoin.SKY_wallet_ReadableWallet_Erase -def SKY_cipher_BitcoinAddress_Null(p0): - return _skycoin.SKY_cipher_BitcoinAddress_Null(p0) -SKY_cipher_BitcoinAddress_Null = _skycoin.SKY_cipher_BitcoinAddress_Null +def SKY_cli_LoadConfig(): + return _skycoin.SKY_cli_LoadConfig() +SKY_cli_LoadConfig = _skycoin.SKY_cli_LoadConfig -def SKY_cipher_BitcoinAddress_Bytes(p0): - return _skycoin.SKY_cipher_BitcoinAddress_Bytes(p0) -SKY_cipher_BitcoinAddress_Bytes = _skycoin.SKY_cipher_BitcoinAddress_Bytes +def SKY_cli_Config_FullWalletPath(p0): + return _skycoin.SKY_cli_Config_FullWalletPath(p0) +SKY_cli_Config_FullWalletPath = _skycoin.SKY_cli_Config_FullWalletPath -def SKY_cipher_BitcoinAddress_Verify(p0, p1): - return _skycoin.SKY_cipher_BitcoinAddress_Verify(p0, p1) -SKY_cipher_BitcoinAddress_Verify = _skycoin.SKY_cipher_BitcoinAddress_Verify +def SKY_cli_Config_FullDBPath(p0): + return _skycoin.SKY_cli_Config_FullDBPath(p0) +SKY_cli_Config_FullDBPath = _skycoin.SKY_cli_Config_FullDBPath -def SKY_cipher_BitcoinAddress_String(p0): - return _skycoin.SKY_cipher_BitcoinAddress_String(p0) -SKY_cipher_BitcoinAddress_String = _skycoin.SKY_cipher_BitcoinAddress_String +def SKY_cli_NewApp(p0): + return _skycoin.SKY_cli_NewApp(p0) +SKY_cli_NewApp = _skycoin.SKY_cli_NewApp -def SKY_cipher_BitcoinAddress_Checksum(p0, p1): - return _skycoin.SKY_cipher_BitcoinAddress_Checksum(p0, p1) -SKY_cipher_BitcoinAddress_Checksum = _skycoin.SKY_cipher_BitcoinAddress_Checksum +def SKY_cli_RPCClientFromContext(p0): + return _skycoin.SKY_cli_RPCClientFromContext(p0) +SKY_cli_RPCClientFromContext = _skycoin.SKY_cli_RPCClientFromContext -def SKY_coin_Create_Transaction(): - return _skycoin.SKY_coin_Create_Transaction() -SKY_coin_Create_Transaction = _skycoin.SKY_coin_Create_Transaction +def SKY_cli_ConfigFromContext(p0): + return _skycoin.SKY_cli_ConfigFromContext(p0) +SKY_cli_ConfigFromContext = _skycoin.SKY_cli_ConfigFromContext -def SKY_coin_Transaction_Copy(p0): - return _skycoin.SKY_coin_Transaction_Copy(p0) -SKY_coin_Transaction_Copy = _skycoin.SKY_coin_Transaction_Copy +def SKY_cli_PasswordFromBytes_Password(): + return _skycoin.SKY_cli_PasswordFromBytes_Password() +SKY_cli_PasswordFromBytes_Password = _skycoin.SKY_cli_PasswordFromBytes_Password -def SKY_coin_GetTransactionObject(p0): - return _skycoin.SKY_coin_GetTransactionObject(p0) -SKY_coin_GetTransactionObject = _skycoin.SKY_coin_GetTransactionObject +def SKY_cli_PasswordFromTerm_Password(): + return _skycoin.SKY_cli_PasswordFromTerm_Password() +SKY_cli_PasswordFromTerm_Password = _skycoin.SKY_cli_PasswordFromTerm_Password -def SKY_coin_Transaction_ResetInputs(p0, p1): - return _skycoin.SKY_coin_Transaction_ResetInputs(p0, p1) -SKY_coin_Transaction_ResetInputs = _skycoin.SKY_coin_Transaction_ResetInputs +def SKY_coin_UxOut_Hash(p0, p1): + return _skycoin.SKY_coin_UxOut_Hash(p0, p1) +SKY_coin_UxOut_Hash = _skycoin.SKY_coin_UxOut_Hash -def SKY_coin_Transaction_GetInputsCount(p0): - return _skycoin.SKY_coin_Transaction_GetInputsCount(p0) -SKY_coin_Transaction_GetInputsCount = _skycoin.SKY_coin_Transaction_GetInputsCount +def SKY_coin_UxOut_SnapshotHash(p0, p1): + return _skycoin.SKY_coin_UxOut_SnapshotHash(p0, p1) +SKY_coin_UxOut_SnapshotHash = _skycoin.SKY_coin_UxOut_SnapshotHash -def SKY_coin_Transaction_GetInputAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_GetInputAt(p0, p1, p2) -SKY_coin_Transaction_GetInputAt = _skycoin.SKY_coin_Transaction_GetInputAt +def SKY_coin_UxBody_Hash(p0, p1): + return _skycoin.SKY_coin_UxBody_Hash(p0, p1) +SKY_coin_UxBody_Hash = _skycoin.SKY_coin_UxBody_Hash -def SKY_coin_Transaction_SetInputAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_SetInputAt(p0, p1, p2) -SKY_coin_Transaction_SetInputAt = _skycoin.SKY_coin_Transaction_SetInputAt +def SKY_coin_UxOut_CoinHours(p0, p1): + return _skycoin.SKY_coin_UxOut_CoinHours(p0, p1) +SKY_coin_UxOut_CoinHours = _skycoin.SKY_coin_UxOut_CoinHours -def SKY_coin_Transaction_GetOutputsCount(p0): - return _skycoin.SKY_coin_Transaction_GetOutputsCount(p0) -SKY_coin_Transaction_GetOutputsCount = _skycoin.SKY_coin_Transaction_GetOutputsCount +def SKY_coin_UxArray_Hashes(*args): + return _skycoin.SKY_coin_UxArray_Hashes(*args) +SKY_coin_UxArray_Hashes = _skycoin.SKY_coin_UxArray_Hashes -def SKY_coin_Transaction_GetOutputAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_GetOutputAt(p0, p1, p2) -SKY_coin_Transaction_GetOutputAt = _skycoin.SKY_coin_Transaction_GetOutputAt +def SKY_coin_UxArray_HasDupes(*args): + return _skycoin.SKY_coin_UxArray_HasDupes(*args) +SKY_coin_UxArray_HasDupes = _skycoin.SKY_coin_UxArray_HasDupes -def SKY_coin_Transaction_SetOutputAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_SetOutputAt(p0, p1, p2) -SKY_coin_Transaction_SetOutputAt = _skycoin.SKY_coin_Transaction_SetOutputAt +def SKY_coin_UxArray_Sort(): + return _skycoin.SKY_coin_UxArray_Sort() +SKY_coin_UxArray_Sort = _skycoin.SKY_coin_UxArray_Sort -def SKY_coin_Transaction_GetSignaturesCount(p0): - return _skycoin.SKY_coin_Transaction_GetSignaturesCount(p0) -SKY_coin_Transaction_GetSignaturesCount = _skycoin.SKY_coin_Transaction_GetSignaturesCount +def SKY_coin_UxArray_Len(): + return _skycoin.SKY_coin_UxArray_Len() +SKY_coin_UxArray_Len = _skycoin.SKY_coin_UxArray_Len -def SKY_coin_Transaction_GetSignatureAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_GetSignatureAt(p0, p1, p2) -SKY_coin_Transaction_GetSignatureAt = _skycoin.SKY_coin_Transaction_GetSignatureAt +def SKY_coin_UxArray_Less(*args): + return _skycoin.SKY_coin_UxArray_Less(*args) +SKY_coin_UxArray_Less = _skycoin.SKY_coin_UxArray_Less -def SKY_coin_Transaction_SetSignatureAt(p0, p1, p2): - return _skycoin.SKY_coin_Transaction_SetSignatureAt(p0, p1, p2) -SKY_coin_Transaction_SetSignatureAt = _skycoin.SKY_coin_Transaction_SetSignatureAt +def SKY_coin_UxArray_Swap(*args): + return _skycoin.SKY_coin_UxArray_Swap(*args) +SKY_coin_UxArray_Swap = _skycoin.SKY_coin_UxArray_Swap -def SKY_coin_Transaction_PushSignature(p0, p1): - return _skycoin.SKY_coin_Transaction_PushSignature(p0, p1) -SKY_coin_Transaction_PushSignature = _skycoin.SKY_coin_Transaction_PushSignature +def SKY_coin_UxArray_Coins(*args): + return _skycoin.SKY_coin_UxArray_Coins(*args) +SKY_coin_UxArray_Coins = _skycoin.SKY_coin_UxArray_Coins -def SKY_coin_Transaction_ResetOutputs(p0, p1): - return _skycoin.SKY_coin_Transaction_ResetOutputs(p0, p1) -SKY_coin_Transaction_ResetOutputs = _skycoin.SKY_coin_Transaction_ResetOutputs +def SKY_coin_UxArray_CoinHours(*args): + return _skycoin.SKY_coin_UxArray_CoinHours(*args) +SKY_coin_UxArray_CoinHours = _skycoin.SKY_coin_UxArray_CoinHours -def SKY_coin_Transaction_ResetSignatures(p0, p1): - return _skycoin.SKY_coin_Transaction_ResetSignatures(p0, p1) -SKY_coin_Transaction_ResetSignatures = _skycoin.SKY_coin_Transaction_ResetSignatures +def SKY_coin_UxArray_Sub(*args): + return _skycoin.SKY_coin_UxArray_Sub(*args) +SKY_coin_UxArray_Sub = _skycoin.SKY_coin_UxArray_Sub + +def SKY_coin_UxArray_Add(*args): + return _skycoin.SKY_coin_UxArray_Add(*args) +SKY_coin_UxArray_Add = _skycoin.SKY_coin_UxArray_Add -def SKY_coin_Transaction_Verify(p0): - return _skycoin.SKY_coin_Transaction_Verify(p0) -SKY_coin_Transaction_Verify = _skycoin.SKY_coin_Transaction_Verify +def SKY_coin_NewAddressUxOuts(*args): + return _skycoin.SKY_coin_NewAddressUxOuts(*args) +SKY_coin_NewAddressUxOuts = _skycoin.SKY_coin_NewAddressUxOuts -def SKY_coin_Transaction_VerifyInput(*args): - return _skycoin.SKY_coin_Transaction_VerifyInput(*args) -SKY_coin_Transaction_VerifyInput = _skycoin.SKY_coin_Transaction_VerifyInput +def SKY_coin_AddressUxOuts_Keys(*args): + return _skycoin.SKY_coin_AddressUxOuts_Keys(*args) +SKY_coin_AddressUxOuts_Keys = _skycoin.SKY_coin_AddressUxOuts_Keys -def SKY_coin_Transaction_PushInput(p0, p1): - return _skycoin.SKY_coin_Transaction_PushInput(p0, p1) -SKY_coin_Transaction_PushInput = _skycoin.SKY_coin_Transaction_PushInput +def SKY_coin_AddressUxOuts_Flatten(*args): + return _skycoin.SKY_coin_AddressUxOuts_Flatten(*args) +SKY_coin_AddressUxOuts_Flatten = _skycoin.SKY_coin_AddressUxOuts_Flatten -def SKY_coin_TransactionOutput_UxID(p0, p1, p2): - return _skycoin.SKY_coin_TransactionOutput_UxID(p0, p1, p2) -SKY_coin_TransactionOutput_UxID = _skycoin.SKY_coin_TransactionOutput_UxID +def SKY_coin_AddressUxOuts_Sub(p0, p1): + return _skycoin.SKY_coin_AddressUxOuts_Sub(p0, p1) +SKY_coin_AddressUxOuts_Sub = _skycoin.SKY_coin_AddressUxOuts_Sub -def SKY_coin_Transaction_PushOutput(p0, p1, p2, p3): - return _skycoin.SKY_coin_Transaction_PushOutput(p0, p1, p2, p3) -SKY_coin_Transaction_PushOutput = _skycoin.SKY_coin_Transaction_PushOutput +def SKY_coin_AddressUxOuts_Add(p0, p1): + return _skycoin.SKY_coin_AddressUxOuts_Add(p0, p1) +SKY_coin_AddressUxOuts_Add = _skycoin.SKY_coin_AddressUxOuts_Add -def SKY_coin_Transaction_SignInputs(*args): - return _skycoin.SKY_coin_Transaction_SignInputs(*args) -SKY_coin_Transaction_SignInputs = _skycoin.SKY_coin_Transaction_SignInputs +def SKY_coin_AddressUxOuts_Get(*args): + return _skycoin.SKY_coin_AddressUxOuts_Get(*args) +SKY_coin_AddressUxOuts_Get = _skycoin.SKY_coin_AddressUxOuts_Get -def SKY_coin_Transaction_Size(p0): - return _skycoin.SKY_coin_Transaction_Size(p0) -SKY_coin_Transaction_Size = _skycoin.SKY_coin_Transaction_Size +def SKY_coin_AddressUxOuts_HasKey(p0, p1): + return _skycoin.SKY_coin_AddressUxOuts_HasKey(p0, p1) +SKY_coin_AddressUxOuts_HasKey = _skycoin.SKY_coin_AddressUxOuts_HasKey -def SKY_coin_Transaction_Hash(p0, p1): - return _skycoin.SKY_coin_Transaction_Hash(p0, p1) -SKY_coin_Transaction_Hash = _skycoin.SKY_coin_Transaction_Hash +def SKY_coin_AddressUxOuts_GetOutputLength(p0, p1): + return _skycoin.SKY_coin_AddressUxOuts_GetOutputLength(p0, p1) +SKY_coin_AddressUxOuts_GetOutputLength = _skycoin.SKY_coin_AddressUxOuts_GetOutputLength -def SKY_coin_Transaction_SizeHash(p0, p2): - return _skycoin.SKY_coin_Transaction_SizeHash(p0, p2) -SKY_coin_Transaction_SizeHash = _skycoin.SKY_coin_Transaction_SizeHash +def SKY_coin_AddressUxOuts_Length(p0): + return _skycoin.SKY_coin_AddressUxOuts_Length(p0) +SKY_coin_AddressUxOuts_Length = _skycoin.SKY_coin_AddressUxOuts_Length -def SKY_coin_Transaction_TxID(p0): - return _skycoin.SKY_coin_Transaction_TxID(p0) -SKY_coin_Transaction_TxID = _skycoin.SKY_coin_Transaction_TxID +def SKY_coin_AddressUxOuts_Set(*args): + return _skycoin.SKY_coin_AddressUxOuts_Set(*args) +SKY_coin_AddressUxOuts_Set = _skycoin.SKY_coin_AddressUxOuts_Set -def SKY_coin_Transaction_TxIDHex(p0): - return _skycoin.SKY_coin_Transaction_TxIDHex(p0) -SKY_coin_Transaction_TxIDHex = _skycoin.SKY_coin_Transaction_TxIDHex +def SKY_api_NewClient(p0): + return _skycoin.SKY_api_NewClient(p0) +SKY_api_NewClient = _skycoin.SKY_api_NewClient -def SKY_coin_Transaction_UpdateHeader(p0): - return _skycoin.SKY_coin_Transaction_UpdateHeader(p0) -SKY_coin_Transaction_UpdateHeader = _skycoin.SKY_coin_Transaction_UpdateHeader +def SKY_api_Client_CSRF(p0): + return _skycoin.SKY_api_Client_CSRF(p0) +SKY_api_Client_CSRF = _skycoin.SKY_api_Client_CSRF -def SKY_coin_Transaction_HashInner(p0, p1): - return _skycoin.SKY_coin_Transaction_HashInner(p0, p1) -SKY_coin_Transaction_HashInner = _skycoin.SKY_coin_Transaction_HashInner +def SKY_api_Client_Version(p0): + return _skycoin.SKY_api_Client_Version(p0) +SKY_api_Client_Version = _skycoin.SKY_api_Client_Version -def SKY_coin_Transaction_Serialize(p0): - return _skycoin.SKY_coin_Transaction_Serialize(p0) -SKY_coin_Transaction_Serialize = _skycoin.SKY_coin_Transaction_Serialize +def SKY_api_Client_Outputs(p0): + return _skycoin.SKY_api_Client_Outputs(p0) +SKY_api_Client_Outputs = _skycoin.SKY_api_Client_Outputs -def SKY_coin_TransactionDeserialize(p0): - return _skycoin.SKY_coin_TransactionDeserialize(p0) -SKY_coin_TransactionDeserialize = _skycoin.SKY_coin_TransactionDeserialize +def SKY_api_Client_OutputsForAddresses(p0, p1): + return _skycoin.SKY_api_Client_OutputsForAddresses(p0, p1) +SKY_api_Client_OutputsForAddresses = _skycoin.SKY_api_Client_OutputsForAddresses -def SKY_coin_Transaction_OutputHours(p0): - return _skycoin.SKY_coin_Transaction_OutputHours(p0) -SKY_coin_Transaction_OutputHours = _skycoin.SKY_coin_Transaction_OutputHours +def SKY_api_Client_OutputsForHashes(p0, p1): + return _skycoin.SKY_api_Client_OutputsForHashes(p0, p1) +SKY_api_Client_OutputsForHashes = _skycoin.SKY_api_Client_OutputsForHashes -def SKY_coin_Create_Transactions(): - return _skycoin.SKY_coin_Create_Transactions() -SKY_coin_Create_Transactions = _skycoin.SKY_coin_Create_Transactions +def SKY_api_Client_CoinSupply(p0): + return _skycoin.SKY_api_Client_CoinSupply(p0) +SKY_api_Client_CoinSupply = _skycoin.SKY_api_Client_CoinSupply -def SKY_coin_GetTransactionsObject(p0, p1): - return _skycoin.SKY_coin_GetTransactionsObject(p0, p1) -SKY_coin_GetTransactionsObject = _skycoin.SKY_coin_GetTransactionsObject +def SKY_api_Client_BlockByHash(p0, p1): + return _skycoin.SKY_api_Client_BlockByHash(p0, p1) +SKY_api_Client_BlockByHash = _skycoin.SKY_api_Client_BlockByHash -def SKY_coin_Transactions_Length(p0): - return _skycoin.SKY_coin_Transactions_Length(p0) -SKY_coin_Transactions_Length = _skycoin.SKY_coin_Transactions_Length +def SKY_api_Client_BlockBySeq(p0, p1): + return _skycoin.SKY_api_Client_BlockBySeq(p0, p1) +SKY_api_Client_BlockBySeq = _skycoin.SKY_api_Client_BlockBySeq -def SKY_coin_Transactions_Add(p0, p1): - return _skycoin.SKY_coin_Transactions_Add(p0, p1) -SKY_coin_Transactions_Add = _skycoin.SKY_coin_Transactions_Add +def SKY_api_Client_Blocks(p0, p1): + return _skycoin.SKY_api_Client_Blocks(p0, p1) +SKY_api_Client_Blocks = _skycoin.SKY_api_Client_Blocks -def SKY_coin_Transactions_Fees(p0, p1): - return _skycoin.SKY_coin_Transactions_Fees(p0, p1) -SKY_coin_Transactions_Fees = _skycoin.SKY_coin_Transactions_Fees +def SKY_api_Client_LastBlocks(p0, p1): + return _skycoin.SKY_api_Client_LastBlocks(p0, p1) +SKY_api_Client_LastBlocks = _skycoin.SKY_api_Client_LastBlocks -def SKY_coin_Transactions_GetAt(p0, p1): - return _skycoin.SKY_coin_Transactions_GetAt(p0, p1) -SKY_coin_Transactions_GetAt = _skycoin.SKY_coin_Transactions_GetAt +def SKY_api_Client_BlockchainMetadata(p0): + return _skycoin.SKY_api_Client_BlockchainMetadata(p0) +SKY_api_Client_BlockchainMetadata = _skycoin.SKY_api_Client_BlockchainMetadata -def SKY_coin_Transactions_Hashes(*args): - return _skycoin.SKY_coin_Transactions_Hashes(*args) -SKY_coin_Transactions_Hashes = _skycoin.SKY_coin_Transactions_Hashes +def SKY_api_Client_BlockchainProgress(p0): + return _skycoin.SKY_api_Client_BlockchainProgress(p0) +SKY_api_Client_BlockchainProgress = _skycoin.SKY_api_Client_BlockchainProgress -def SKY_coin_Transactions_Size(p0): - return _skycoin.SKY_coin_Transactions_Size(p0) -SKY_coin_Transactions_Size = _skycoin.SKY_coin_Transactions_Size +def SKY_api_Client_Balance(p0, p1, p2): + return _skycoin.SKY_api_Client_Balance(p0, p1, p2) +SKY_api_Client_Balance = _skycoin.SKY_api_Client_Balance -def SKY_coin_Transactions_TruncateBytesTo(p0, p1): - return _skycoin.SKY_coin_Transactions_TruncateBytesTo(p0, p1) -SKY_coin_Transactions_TruncateBytesTo = _skycoin.SKY_coin_Transactions_TruncateBytesTo +def SKY_api_Client_UxOut(p0, p1): + return _skycoin.SKY_api_Client_UxOut(p0, p1) +SKY_api_Client_UxOut = _skycoin.SKY_api_Client_UxOut -def SKY_coin_SortTransactions(p0, p1): - return _skycoin.SKY_coin_SortTransactions(p0, p1) -SKY_coin_SortTransactions = _skycoin.SKY_coin_SortTransactions +def SKY_api_Client_AddressUxOuts(p0, p1): + return _skycoin.SKY_api_Client_AddressUxOuts(p0, p1) +SKY_api_Client_AddressUxOuts = _skycoin.SKY_api_Client_AddressUxOuts -def SKY_coin_NewSortableTransactions(p0, p1, p2): - return _skycoin.SKY_coin_NewSortableTransactions(p0, p1, p2) -SKY_coin_NewSortableTransactions = _skycoin.SKY_coin_NewSortableTransactions +def SKY_api_Client_Wallet(p0, p1): + return _skycoin.SKY_api_Client_Wallet(p0, p1) +SKY_api_Client_Wallet = _skycoin.SKY_api_Client_Wallet -def SKY_coin_SortableTransactions_Sort(p0): - return _skycoin.SKY_coin_SortableTransactions_Sort(p0) -SKY_coin_SortableTransactions_Sort = _skycoin.SKY_coin_SortableTransactions_Sort +def SKY_api_Client_Wallets(p0): + return _skycoin.SKY_api_Client_Wallets(p0) +SKY_api_Client_Wallets = _skycoin.SKY_api_Client_Wallets -def SKY_coin_SortableTransactions_Len(p0): - return _skycoin.SKY_coin_SortableTransactions_Len(p0) -SKY_coin_SortableTransactions_Len = _skycoin.SKY_coin_SortableTransactions_Len +def SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3): + return _skycoin.SKY_api_Client_CreateUnencryptedWallet(p0, p1, p2, p3) +SKY_api_Client_CreateUnencryptedWallet = _skycoin.SKY_api_Client_CreateUnencryptedWallet -def SKY_coin_SortableTransactions_Less(p0, p1, p2): - return _skycoin.SKY_coin_SortableTransactions_Less(p0, p1, p2) -SKY_coin_SortableTransactions_Less = _skycoin.SKY_coin_SortableTransactions_Less +def SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4): + return _skycoin.SKY_api_Client_CreateEncryptedWallet(p0, p1, p2, p3, p4) +SKY_api_Client_CreateEncryptedWallet = _skycoin.SKY_api_Client_CreateEncryptedWallet -def SKY_coin_SortableTransactions_Swap(p0, p1, p2): - return _skycoin.SKY_coin_SortableTransactions_Swap(p0, p1, p2) -SKY_coin_SortableTransactions_Swap = _skycoin.SKY_coin_SortableTransactions_Swap +def SKY_api_Client_NewWalletAddress(p0, p1, p2, p3): + return _skycoin.SKY_api_Client_NewWalletAddress(p0, p1, p2, p3) +SKY_api_Client_NewWalletAddress = _skycoin.SKY_api_Client_NewWalletAddress -def SKY_coin_VerifyTransactionCoinsSpending(*args): - return _skycoin.SKY_coin_VerifyTransactionCoinsSpending(*args) -SKY_coin_VerifyTransactionCoinsSpending = _skycoin.SKY_coin_VerifyTransactionCoinsSpending +def SKY_api_Client_WalletBalance(p0, p1, p2): + return _skycoin.SKY_api_Client_WalletBalance(p0, p1, p2) +SKY_api_Client_WalletBalance = _skycoin.SKY_api_Client_WalletBalance -def SKY_coin_VerifyTransactionHoursSpending(*args): - return _skycoin.SKY_coin_VerifyTransactionHoursSpending(*args) -SKY_coin_VerifyTransactionHoursSpending = _skycoin.SKY_coin_VerifyTransactionHoursSpending +def SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5): + return _skycoin.SKY_api_Client_Spend(p0, p1, p2, p3, p4, p5) +SKY_api_Client_Spend = _skycoin.SKY_api_Client_Spend -def SKY_cli_GenerateWallet(p0, p2): - return _skycoin.SKY_cli_GenerateWallet(p0, p2) -SKY_cli_GenerateWallet = _skycoin.SKY_cli_GenerateWallet +def SKY_api_Client_CreateTransaction(p0): + return _skycoin.SKY_api_Client_CreateTransaction(p0) +SKY_api_Client_CreateTransaction = _skycoin.SKY_api_Client_CreateTransaction -def SKY_cli_MakeAlphanumericSeed(): - return _skycoin.SKY_cli_MakeAlphanumericSeed() -SKY_cli_MakeAlphanumericSeed = _skycoin.SKY_cli_MakeAlphanumericSeed +def SKY_api_Client_UpdateWallet(p0, p1, p2): + return _skycoin.SKY_api_Client_UpdateWallet(p0, p1, p2) +SKY_api_Client_UpdateWallet = _skycoin.SKY_api_Client_UpdateWallet -def SKY_cli_GetWalletOutputsFromFile(p0, p1, p2): - return _skycoin.SKY_cli_GetWalletOutputsFromFile(p0, p1, p2) -SKY_cli_GetWalletOutputsFromFile = _skycoin.SKY_cli_GetWalletOutputsFromFile +def SKY_api_Client_WalletFolderName(p0): + return _skycoin.SKY_api_Client_WalletFolderName(p0) +SKY_api_Client_WalletFolderName = _skycoin.SKY_api_Client_WalletFolderName -def SKY_cli_GetWalletOutputs(p0, p2): - return _skycoin.SKY_cli_GetWalletOutputs(p0, p2) -SKY_cli_GetWalletOutputs = _skycoin.SKY_cli_GetWalletOutputs +def SKY_api_Client_NewSeed(p0, p1): + return _skycoin.SKY_api_Client_NewSeed(p0, p1) +SKY_api_Client_NewSeed = _skycoin.SKY_api_Client_NewSeed -def SKY_cli_CheckWalletBalance(p0, p1, p2): - return _skycoin.SKY_cli_CheckWalletBalance(p0, p1, p2) -SKY_cli_CheckWalletBalance = _skycoin.SKY_cli_CheckWalletBalance +def SKY_api_Client_WalletSeed(p0, p1, p2): + return _skycoin.SKY_api_Client_WalletSeed(p0, p1, p2) +SKY_api_Client_WalletSeed = _skycoin.SKY_api_Client_WalletSeed -def SKY_cli_GetBalanceOfAddresses(p0, p1, p2): - return _skycoin.SKY_cli_GetBalanceOfAddresses(p0, p1, p2) -SKY_cli_GetBalanceOfAddresses = _skycoin.SKY_cli_GetBalanceOfAddresses +def SKY_api_Client_NetworkConnection(p0, p1): + return _skycoin.SKY_api_Client_NetworkConnection(p0, p1) +SKY_api_Client_NetworkConnection = _skycoin.SKY_api_Client_NetworkConnection -def SKY_cli_App_Run(p0, p1): - return _skycoin.SKY_cli_App_Run(p0, p1) -SKY_cli_App_Run = _skycoin.SKY_cli_App_Run +def SKY_api_Client_NetworkConnections(p0, p1): + return _skycoin.SKY_api_Client_NetworkConnections(p0, p1) +SKY_api_Client_NetworkConnections = _skycoin.SKY_api_Client_NetworkConnections -def SKY_cli_Config_GetCoin(p0): - return _skycoin.SKY_cli_Config_GetCoin(p0) -SKY_cli_Config_GetCoin = _skycoin.SKY_cli_Config_GetCoin +def SKY_api_Client_NetworkDefaultPeers(p0): + return _skycoin.SKY_api_Client_NetworkDefaultPeers(p0) +SKY_api_Client_NetworkDefaultPeers = _skycoin.SKY_api_Client_NetworkDefaultPeers -def SKY_cli_Config_GetRPCAddress(p0): - return _skycoin.SKY_cli_Config_GetRPCAddress(p0) -SKY_cli_Config_GetRPCAddress = _skycoin.SKY_cli_Config_GetRPCAddress +def SKY_api_Client_NetworkTrustedPeers(p0): + return _skycoin.SKY_api_Client_NetworkTrustedPeers(p0) +SKY_api_Client_NetworkTrustedPeers = _skycoin.SKY_api_Client_NetworkTrustedPeers -def SKY_cli_RPCClientFromApp(p0): - return _skycoin.SKY_cli_RPCClientFromApp(p0) -SKY_cli_RPCClientFromApp = _skycoin.SKY_cli_RPCClientFromApp +def SKY_api_Client_NetworkExchangedPeers(p0): + return _skycoin.SKY_api_Client_NetworkExchangedPeers(p0) +SKY_api_Client_NetworkExchangedPeers = _skycoin.SKY_api_Client_NetworkExchangedPeers -def SKY_cli_Getenv(p0): - return _skycoin.SKY_cli_Getenv(p0) -SKY_cli_Getenv = _skycoin.SKY_cli_Getenv +def SKY_api_Client_PendingTransactions(p0): + return _skycoin.SKY_api_Client_PendingTransactions(p0) +SKY_api_Client_PendingTransactions = _skycoin.SKY_api_Client_PendingTransactions -def SKY_cli_Setenv(p0, p1): - return _skycoin.SKY_cli_Setenv(p0, p1) -SKY_cli_Setenv = _skycoin.SKY_cli_Setenv +def SKY_api_Client_Transaction(p0, p1): + return _skycoin.SKY_api_Client_Transaction(p0, p1) +SKY_api_Client_Transaction = _skycoin.SKY_api_Client_Transaction -def SKY_coin_AddUint64(p0, p1): - return _skycoin.SKY_coin_AddUint64(p0, p1) -SKY_coin_AddUint64 = _skycoin.SKY_coin_AddUint64 +def SKY_api_Client_Transactions(p0, p1): + return _skycoin.SKY_api_Client_Transactions(p0, p1) +SKY_api_Client_Transactions = _skycoin.SKY_api_Client_Transactions -def SKY_coin_Uint64ToInt64(p0): - return _skycoin.SKY_coin_Uint64ToInt64(p0) -SKY_coin_Uint64ToInt64 = _skycoin.SKY_coin_Uint64ToInt64 +def SKY_api_Client_ConfirmedTransactions(p0, p1): + return _skycoin.SKY_api_Client_ConfirmedTransactions(p0, p1) +SKY_api_Client_ConfirmedTransactions = _skycoin.SKY_api_Client_ConfirmedTransactions -def SKY_coin_Int64ToUint64(p0): - return _skycoin.SKY_coin_Int64ToUint64(p0) -SKY_coin_Int64ToUint64 = _skycoin.SKY_coin_Int64ToUint64 +def SKY_api_Client_UnconfirmedTransactions(p0, p1): + return _skycoin.SKY_api_Client_UnconfirmedTransactions(p0, p1) +SKY_api_Client_UnconfirmedTransactions = _skycoin.SKY_api_Client_UnconfirmedTransactions -def SKY_coin_IntToUint32(p0): - return _skycoin.SKY_coin_IntToUint32(p0) -SKY_coin_IntToUint32 = _skycoin.SKY_coin_IntToUint32 +def SKY_api_Client_InjectTransaction(p0, p1): + return _skycoin.SKY_api_Client_InjectTransaction(p0, p1) +SKY_api_Client_InjectTransaction = _skycoin.SKY_api_Client_InjectTransaction -def SKY_iputil_LocalhostIP(): - return _skycoin.SKY_iputil_LocalhostIP() -SKY_iputil_LocalhostIP = _skycoin.SKY_iputil_LocalhostIP +def SKY_api_Client_ResendUnconfirmedTransactions(p0): + return _skycoin.SKY_api_Client_ResendUnconfirmedTransactions(p0) +SKY_api_Client_ResendUnconfirmedTransactions = _skycoin.SKY_api_Client_ResendUnconfirmedTransactions -def SKY_iputil_IsLocalhost(p0): - return _skycoin.SKY_iputil_IsLocalhost(p0) -SKY_iputil_IsLocalhost = _skycoin.SKY_iputil_IsLocalhost +def SKY_api_Client_RawTransaction(p0, p1): + return _skycoin.SKY_api_Client_RawTransaction(p0, p1) +SKY_api_Client_RawTransaction = _skycoin.SKY_api_Client_RawTransaction -def SKY_iputil_SplitAddr(p0): - return _skycoin.SKY_iputil_SplitAddr(p0) -SKY_iputil_SplitAddr = _skycoin.SKY_iputil_SplitAddr +def SKY_api_Client_AddressTransactions(p0, p1): + return _skycoin.SKY_api_Client_AddressTransactions(p0, p1) +SKY_api_Client_AddressTransactions = _skycoin.SKY_api_Client_AddressTransactions -def SKY_certutil_NewTLSCertPair(p0, p1, p2): - return _skycoin.SKY_certutil_NewTLSCertPair(p0, p1, p2) -SKY_certutil_NewTLSCertPair = _skycoin.SKY_certutil_NewTLSCertPair +def SKY_api_Client_Richlist(p0, p1): + return _skycoin.SKY_api_Client_Richlist(p0, p1) +SKY_api_Client_Richlist = _skycoin.SKY_api_Client_Richlist -def SKY_cipher_DecodeBase58Address(p0, p1): - return _skycoin.SKY_cipher_DecodeBase58Address(p0, p1) -SKY_cipher_DecodeBase58Address = _skycoin.SKY_cipher_DecodeBase58Address +def SKY_api_Client_AddressCount(p0): + return _skycoin.SKY_api_Client_AddressCount(p0) +SKY_api_Client_AddressCount = _skycoin.SKY_api_Client_AddressCount -def SKY_cipher_AddressFromBytes(p0, p1): - return _skycoin.SKY_cipher_AddressFromBytes(p0, p1) -SKY_cipher_AddressFromBytes = _skycoin.SKY_cipher_AddressFromBytes +def SKY_api_Client_UnloadWallet(p0, p1): + return _skycoin.SKY_api_Client_UnloadWallet(p0, p1) +SKY_api_Client_UnloadWallet = _skycoin.SKY_api_Client_UnloadWallet -def SKY_cipher_AddressFromPubKey(p0, p1): - return _skycoin.SKY_cipher_AddressFromPubKey(p0, p1) -SKY_cipher_AddressFromPubKey = _skycoin.SKY_cipher_AddressFromPubKey +def SKY_api_Client_Health(p0): + return _skycoin.SKY_api_Client_Health(p0) +SKY_api_Client_Health = _skycoin.SKY_api_Client_Health -def SKY_cipher_AddressFromSecKey(p0, p1): - return _skycoin.SKY_cipher_AddressFromSecKey(p0, p1) -SKY_cipher_AddressFromSecKey = _skycoin.SKY_cipher_AddressFromSecKey +def SKY_api_Client_EncryptWallet(p0, p1, p2): + return _skycoin.SKY_api_Client_EncryptWallet(p0, p1, p2) +SKY_api_Client_EncryptWallet = _skycoin.SKY_api_Client_EncryptWallet -def SKY_cipher_Address_Null(p0): - return _skycoin.SKY_cipher_Address_Null(p0) -SKY_cipher_Address_Null = _skycoin.SKY_cipher_Address_Null +def SKY_api_Client_DecryptWallet(p0, p1, p2): + return _skycoin.SKY_api_Client_DecryptWallet(p0, p1, p2) +SKY_api_Client_DecryptWallet = _skycoin.SKY_api_Client_DecryptWallet -def SKY_cipher_Address_Bytes(p0): - return _skycoin.SKY_cipher_Address_Bytes(p0) -SKY_cipher_Address_Bytes = _skycoin.SKY_cipher_Address_Bytes +def SKY_cipher_Ripemd160_Set(p0, p1): + return _skycoin.SKY_cipher_Ripemd160_Set(p0, p1) +SKY_cipher_Ripemd160_Set = _skycoin.SKY_cipher_Ripemd160_Set -def SKY_cipher_Address_Verify(p0, p1): - return _skycoin.SKY_cipher_Address_Verify(p0, p1) -SKY_cipher_Address_Verify = _skycoin.SKY_cipher_Address_Verify +def SKY_cipher_HashRipemd160(p0, p1): + return _skycoin.SKY_cipher_HashRipemd160(p0, p1) +SKY_cipher_HashRipemd160 = _skycoin.SKY_cipher_HashRipemd160 -def SKY_cipher_Address_String(p0): - return _skycoin.SKY_cipher_Address_String(p0) -SKY_cipher_Address_String = _skycoin.SKY_cipher_Address_String +def SKY_cipher_SHA256_Set(p0, p1): + return _skycoin.SKY_cipher_SHA256_Set(p0, p1) +SKY_cipher_SHA256_Set = _skycoin.SKY_cipher_SHA256_Set -def SKY_cipher_Address_Checksum(p0, p1): - return _skycoin.SKY_cipher_Address_Checksum(p0, p1) -SKY_cipher_Address_Checksum = _skycoin.SKY_cipher_Address_Checksum +def SKY_cipher_SHA256_Hex(p0): + return _skycoin.SKY_cipher_SHA256_Hex(p0) +SKY_cipher_SHA256_Hex = _skycoin.SKY_cipher_SHA256_Hex -def SKY_wallet_NewReadableEntry(p0, p1): - return _skycoin.SKY_wallet_NewReadableEntry(p0, p1) -SKY_wallet_NewReadableEntry = _skycoin.SKY_wallet_NewReadableEntry +def SKY_cipher_SHA256_Xor(p0, p1, p2): + return _skycoin.SKY_cipher_SHA256_Xor(p0, p1, p2) +SKY_cipher_SHA256_Xor = _skycoin.SKY_cipher_SHA256_Xor -def SKY_wallet_LoadReadableWallet(p0): - return _skycoin.SKY_wallet_LoadReadableWallet(p0) -SKY_wallet_LoadReadableWallet = _skycoin.SKY_wallet_LoadReadableWallet +def SKY_cipher_SumSHA256(p0, p1): + return _skycoin.SKY_cipher_SumSHA256(p0, p1) +SKY_cipher_SumSHA256 = _skycoin.SKY_cipher_SumSHA256 -def SKY_wallet_ReadableWallet_Save(p0, p1): - return _skycoin.SKY_wallet_ReadableWallet_Save(p0, p1) -SKY_wallet_ReadableWallet_Save = _skycoin.SKY_wallet_ReadableWallet_Save +def SKY_cipher_SHA256FromHex(p0, p1): + return _skycoin.SKY_cipher_SHA256FromHex(p0, p1) +SKY_cipher_SHA256FromHex = _skycoin.SKY_cipher_SHA256FromHex -def SKY_wallet_ReadableWallet_Load(p0, p1): - return _skycoin.SKY_wallet_ReadableWallet_Load(p0, p1) -SKY_wallet_ReadableWallet_Load = _skycoin.SKY_wallet_ReadableWallet_Load +def SKY_cipher_DoubleSHA256(p0, p1): + return _skycoin.SKY_cipher_DoubleSHA256(p0, p1) +SKY_cipher_DoubleSHA256 = _skycoin.SKY_cipher_DoubleSHA256 -def SKY_wallet_ReadableWallet_Erase(p0): - return _skycoin.SKY_wallet_ReadableWallet_Erase(p0) -SKY_wallet_ReadableWallet_Erase = _skycoin.SKY_wallet_ReadableWallet_Erase +def SKY_cipher_AddSHA256(p0, p1, p2): + return _skycoin.SKY_cipher_AddSHA256(p0, p1, p2) +SKY_cipher_AddSHA256 = _skycoin.SKY_cipher_AddSHA256 -def SKY_wallet_Entry_Verify(p0): - return _skycoin.SKY_wallet_Entry_Verify(p0) -SKY_wallet_Entry_Verify = _skycoin.SKY_wallet_Entry_Verify +def SKY_cipher_Merkle(p0, p1): + return _skycoin.SKY_cipher_Merkle(p0, p1) +SKY_cipher_Merkle = _skycoin.SKY_cipher_Merkle -def SKY_wallet_Entry_VerifyPublic(p0): - return _skycoin.SKY_wallet_Entry_VerifyPublic(p0) -SKY_wallet_Entry_VerifyPublic = _skycoin.SKY_wallet_Entry_VerifyPublic +def SKY_cipher_SHA256_Null(p0): + return _skycoin.SKY_cipher_SHA256_Null(p0) +SKY_cipher_SHA256_Null = _skycoin.SKY_cipher_SHA256_Null def SKY_JsonEncode_Handle(p0): return _skycoin.SKY_JsonEncode_Handle(p0) @@ -2021,97 +2101,17 @@ def SKY_api_Handle_GetBuildInfoData(p0): return _skycoin.SKY_api_Handle_GetBuildInfoData(p0) SKY_api_Handle_GetBuildInfoData = _skycoin.SKY_api_Handle_GetBuildInfoData -def SKY_api_NewWalletResponse(p0): - return _skycoin.SKY_api_NewWalletResponse(p0) -SKY_api_NewWalletResponse = _skycoin.SKY_api_NewWalletResponse - -def SKY_webrpc_NewClient(p0): - return _skycoin.SKY_webrpc_NewClient(p0) -SKY_webrpc_NewClient = _skycoin.SKY_webrpc_NewClient - -def SKY_webrpc_Client_CSRF(p0): - return _skycoin.SKY_webrpc_Client_CSRF(p0) -SKY_webrpc_Client_CSRF = _skycoin.SKY_webrpc_Client_CSRF - -def SKY_webrpc_Client_InjectTransaction(p0, p1): - return _skycoin.SKY_webrpc_Client_InjectTransaction(p0, p1) -SKY_webrpc_Client_InjectTransaction = _skycoin.SKY_webrpc_Client_InjectTransaction - -def SKY_webrpc_Client_GetStatus(p0, p1): - return _skycoin.SKY_webrpc_Client_GetStatus(p0, p1) -SKY_webrpc_Client_GetStatus = _skycoin.SKY_webrpc_Client_GetStatus - -def SKY_webrpc_Client_GetTransactionByID(p0, p1, p2): - return _skycoin.SKY_webrpc_Client_GetTransactionByID(p0, p1, p2) -SKY_webrpc_Client_GetTransactionByID = _skycoin.SKY_webrpc_Client_GetTransactionByID - -def SKY_webrpc_Client_GetAddressUxOuts(p0, p1): - return _skycoin.SKY_webrpc_Client_GetAddressUxOuts(p0, p1) -SKY_webrpc_Client_GetAddressUxOuts = _skycoin.SKY_webrpc_Client_GetAddressUxOuts - -def SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2): - return _skycoin.SKY_webrpc_Client_GetBlocksInRange(p0, p1, p2) -SKY_webrpc_Client_GetBlocksInRange = _skycoin.SKY_webrpc_Client_GetBlocksInRange - -def SKY_webrpc_Client_GetBlocksBySeq(p0, p1): - return _skycoin.SKY_webrpc_Client_GetBlocksBySeq(p0, p1) -SKY_webrpc_Client_GetBlocksBySeq = _skycoin.SKY_webrpc_Client_GetBlocksBySeq - -def SKY_webrpc_Client_GetLastBlocks(p0, p1): - return _skycoin.SKY_webrpc_Client_GetLastBlocks(p0, p1) -SKY_webrpc_Client_GetLastBlocks = _skycoin.SKY_webrpc_Client_GetLastBlocks - -def SKY_bip39_NewDefaultMnemomic(): - return _skycoin.SKY_bip39_NewDefaultMnemomic() -SKY_bip39_NewDefaultMnemomic = _skycoin.SKY_bip39_NewDefaultMnemomic - -def SKY_bip39_NewEntropy(p0): - return _skycoin.SKY_bip39_NewEntropy(p0) -SKY_bip39_NewEntropy = _skycoin.SKY_bip39_NewEntropy - -def SKY_bip39_NewMnemonic(p0): - return _skycoin.SKY_bip39_NewMnemonic(p0) -SKY_bip39_NewMnemonic = _skycoin.SKY_bip39_NewMnemonic - -def SKY_bip39_MnemonicToByteArray(p0): - return _skycoin.SKY_bip39_MnemonicToByteArray(p0) -SKY_bip39_MnemonicToByteArray = _skycoin.SKY_bip39_MnemonicToByteArray - -def SKY_bip39_IsMnemonicValid(p0): - return _skycoin.SKY_bip39_IsMnemonicValid(p0) -SKY_bip39_IsMnemonicValid = _skycoin.SKY_bip39_IsMnemonicValid - -def SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4): - return _skycoin.SKY_cli_CreateRawTxFromWallet(p0, p1, p2, p3, p4) -SKY_cli_CreateRawTxFromWallet = _skycoin.SKY_cli_CreateRawTxFromWallet - -def SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5): - return _skycoin.SKY_cli_CreateRawTxFromAddress(p0, p1, p2, p3, p4, p5) -SKY_cli_CreateRawTxFromAddress = _skycoin.SKY_cli_CreateRawTxFromAddress - -def SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5): - return _skycoin.SKY_cli_CreateRawTx(p0, p1, p2, p3, p4, p5) -SKY_cli_CreateRawTx = _skycoin.SKY_cli_CreateRawTx - -def SKY_cli_NewTransaction(p0, p1, p2): - return _skycoin.SKY_cli_NewTransaction(p0, p1, p2) -SKY_cli_NewTransaction = _skycoin.SKY_cli_NewTransaction - -def SKY_testutil_MakeAddress(p0): - return _skycoin.SKY_testutil_MakeAddress(p0) -SKY_testutil_MakeAddress = _skycoin.SKY_testutil_MakeAddress - -def SKY_apputil_CatchInterruptPanic(): - return _skycoin.SKY_apputil_CatchInterruptPanic() -SKY_apputil_CatchInterruptPanic = _skycoin.SKY_apputil_CatchInterruptPanic +def SKY_logging_EnableColors(): + return _skycoin.SKY_logging_EnableColors() +SKY_logging_EnableColors = _skycoin.SKY_logging_EnableColors -def SKY_apputil_CatchDebug(): - return _skycoin.SKY_apputil_CatchDebug() -SKY_apputil_CatchDebug = _skycoin.SKY_apputil_CatchDebug +def SKY_logging_DisableColors(): + return _skycoin.SKY_logging_DisableColors() +SKY_logging_DisableColors = _skycoin.SKY_logging_DisableColors -def SKY_apputil_PrintProgramStatus(): - return _skycoin.SKY_apputil_PrintProgramStatus() -SKY_apputil_PrintProgramStatus = _skycoin.SKY_apputil_PrintProgramStatus +def SKY_logging_Disable(): + return _skycoin.SKY_logging_Disable() +SKY_logging_Disable = _skycoin.SKY_logging_Disable class api__RichlistParams(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, api__RichlistParams, name, value) diff --git a/swig/pyskycoin_wrap.c b/swig/pyskycoin_wrap.c index 10312447..5fc6fe92 100644 --- a/swig/pyskycoin_wrap.c +++ b/swig/pyskycoin_wrap.c @@ -4167,16 +4167,31 @@ SWIG_From_long_SS_long (long long value) #endif +SWIGINTERNINLINE PyObject* +SWIG_From_unsigned_SS_long (unsigned long value) +{ + return (value > LONG_MAX) ? + PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); +} + + +SWIGINTERNINLINE PyObject * +SWIG_From_unsigned_SS_char (unsigned char value) +{ + return SWIG_From_unsigned_SS_long (value); +} + + SWIGINTERN int -SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) +SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) { unsigned long v; int res = SWIG_AsVal_unsigned_SS_long (obj, &v); if (SWIG_IsOK(res)) { - if ((v > UCHAR_MAX)) { + if ((v > UINT_MAX)) { return SWIG_OverflowError; } else { - if (val) *val = (unsigned char)(v); + if (val) *val = (unsigned int)(v); } } return res; @@ -4184,35 +4199,20 @@ SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) SWIGINTERN int -SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) +SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val) { unsigned long v; int res = SWIG_AsVal_unsigned_SS_long (obj, &v); if (SWIG_IsOK(res)) { - if ((v > UINT_MAX)) { + if ((v > UCHAR_MAX)) { return SWIG_OverflowError; } else { - if (val) *val = (unsigned int)(v); + if (val) *val = (unsigned char)(v); } } return res; } - -SWIGINTERNINLINE PyObject* -SWIG_From_unsigned_SS_long (unsigned long value) -{ - return (value > LONG_MAX) ? - PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); -} - - -SWIGINTERNINLINE PyObject * -SWIG_From_unsigned_SS_char (unsigned char value) -{ - return SWIG_From_unsigned_SS_long (value); -} - SWIGINTERN int cipher__Address___eq__(cipher__Address *self,cipher__Address *a){ if( self->Version == a->Version ){ return memcmp(self->Key, a->Key, sizeof(a->Key)) == 0; @@ -9066,57 +9066,55 @@ SWIGINTERN PyObject *GoSlice_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_SKY_cipher_Ripemd160_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_RandByte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Ripemd160 *arg1 = (cipher__Ripemd160 *) 0 ; - GoSlice arg2 ; + GoInt arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + long long val1 ; + int ecode1 = 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Ripemd160_Set",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); - cipher_Ripemd160* p = (cipher_Ripemd160*)argp; - arg1 = &p->data; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_RandByte",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_cipher_RandByte" "', argument " "1"" of type '" "GoInt""'"); + } + arg1 = (GoInt)(val1); + result = (GoUint32)SKY_cipher_RandByte(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_Ripemd160_Set', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } - result = (GoUint32)SKY_cipher_Ripemd160_Set((unsigned char (*)[20])arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_NewPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_HashRipemd160",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewPubKey",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_HashRipemd160', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewPubKey', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; @@ -9124,13 +9122,13 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(sel } { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); - cipher_Ripemd160* p = (cipher_Ripemd160*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_cipher_HashRipemd160(arg1,(unsigned char (*)[20])arg2); + result = (GoUint32)SKY_cipher_NewPubKey(arg1,(unsigned char (*)[33])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9138,35 +9136,34 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; - GoSlice arg2 ; + GoString arg1 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256_Set",&obj0,&obj1)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg1 = &p->data; - } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromHex",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256_Set', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_PubKeyFromHex', expecting string"); } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_cipher_SHA256_Set((unsigned char (*)[32])arg1,arg2); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg2 = &p->data; + } + result = (GoUint32)SKY_cipher_PubKeyFromHex(arg1,(unsigned char (*)[33])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9174,57 +9171,56 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Hex",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromSecKey",&obj0,&obj1)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; arg1 = &p->data; } - result = (GoUint32)SKY_cipher_SHA256_Hex((unsigned char (*)[32])arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_PubKeyFromSecKey((unsigned char (*)[32])arg1,(unsigned char (*)[33])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + cipher__Sig *arg1 = (cipher__Sig *) 0 ; cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + cipher__PubKey *arg3 = (cipher__PubKey *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SHA256_Xor",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_PubKeyFromSig",&obj0,&obj1,&obj2)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; arg1 = &p->data; } { @@ -9237,13 +9233,13 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), } { void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; arg3 = &p->data; } - result = (GoUint32)SKY_cipher_SHA256_Xor((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); + result = (GoUint32)SKY_cipher_PubKeyFromSig((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[33])arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9251,35 +9247,22 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_SumSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SumSHA256",&obj0,&obj1)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SumSHA256', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; - } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Verify",&obj0)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_cipher_SumSHA256(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_cipher_PubKey_Verify((unsigned char (*)[33])arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9287,56 +9270,88 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SumSHA256(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256FromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256FromHex",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256FromHex', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Hex",&obj0)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_cipher_SHA256FromHex(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_cipher_PubKey_Hex((unsigned char (*)[33])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyRipemd160",&obj0,&obj1)) SWIG_fail; + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; + } + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); + cipher_Ripemd160* p = (cipher_Ripemd160*)argp; + arg2 = &p->data; + } + result = (GoUint32)SKY_cipher_PubKeyRipemd160((unsigned char (*)[33])arg1,(unsigned char (*)[20])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_NewSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DoubleSHA256",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSecKey",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DoubleSHA256', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSecKey', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; @@ -9344,13 +9359,13 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self } { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_cipher_DoubleSHA256(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_cipher_NewSecKey(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9358,42 +9373,34 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_cipher_AddSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + GoString arg1 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_AddSHA256",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromHex",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg1 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromHex', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; arg2 = &p->data; } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; - } - result = (GoUint32)SKY_cipher_AddSHA256((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); + result = (GoUint32)SKY_cipher_SecKeyFromHex(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9401,31 +9408,22 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_AddSHA256(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_Merkle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice *arg1 = (GoSlice *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Merkle",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GoSlice, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Merkle" "', argument " "1"" of type '" "GoSlice *""'"); - } - arg1 = (GoSlice *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Verify",&obj0)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_cipher_Merkle(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_cipher_SecKey_Verify((unsigned char (*)[32])arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -9433,32 +9431,33 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Merkle(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Null",&obj0)) SWIG_fail; + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Hex",&obj0)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; arg1 = &p->data; } - result = (GoUint32)SKY_cipher_SHA256_Null((unsigned char (*)[32])arg1,arg2); + result = (GoUint32)SKY_cipher_SecKey_Hex((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -9466,36 +9465,44 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Null(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_ECDH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_String2Hex",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_ECDH",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_String2Hex', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_base58_String2Hex(arg1,arg2); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg2 = &p->data; + } + result = (GoUint32)SKY_cipher_ECDH((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -9503,106 +9510,104 @@ SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; + GoSlice arg1 ; + cipher__Sig *arg2 = (cipher__Sig *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToInt",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSig",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToInt', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSig', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_base58_Base58_ToInt(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_NewSig(arg1,(unsigned char (*)[65])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SigFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoString arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + cipher__Sig *arg2 = (cipher__Sig *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToHex",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SigFromHex",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToHex', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SigFromHex', expecting string"); } (&arg1)->p = buffer; (&arg1)->n = size - 1; } - result = (GoUint32)SKY_base58_Base58_ToHex(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_SigFromHex(arg1,(unsigned char (*)[65])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Sig_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; + cipher__Sig *arg1 = (cipher__Sig *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_Base582Int",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_Base582Int', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - result = (GoUint32)SKY_base58_Base58_Base582Int(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Sig_Hex",&obj0)) SWIG_fail; + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg1 = &p->data; + } + result = (GoUint32)SKY_cipher_Sig_Hex((unsigned char (*)[65])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -9610,278 +9615,297 @@ SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_base58_Base582Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SignHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + cipher__Sig *arg3 = (cipher__Sig *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SignHash",&obj0,&obj1,&obj2)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base582Hex",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base582Hex', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_base58_Base582Hex(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_cipher_SignHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[65])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyAddressSignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + cipher__Sig *arg2 = (cipher__Sig *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyAddressSignedHash",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_VerifyAddressSignedHash" "', argument " "1"" of type '" "cipher__Address *""'"); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_BitHex",&obj0)) SWIG_fail; + arg1 = (cipher__Address *)(argp1); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_BitHex', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_base58_Base58_BitHex(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_cipher_VerifyAddressSignedHash(arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Int2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoInt arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - long long val1 ; - int ecode1 = 0 ; - GoString temp2 ; + cipher__Sig *arg1 = (cipher__Sig *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_VerifySignedHash",&obj0,&obj1)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Int2Base58",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_base58_Int2Base58" "', argument " "1"" of type '" "GoInt""'"); - } - arg1 = (GoInt)(val1); - result = (GoUint32)SKY_base58_Int2Base58(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_VerifySignedHash((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyPubKeySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__Sig *arg2 = (cipher__Sig *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyPubKeySignedHash",&obj0,&obj1,&obj2)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_base58_Hex2Base58(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_cipher_VerifyPubKeySignedHash((unsigned char (*)[33])arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateKeyPair",&obj0,&obj1)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58String",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58String', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_base58_Hex2Base58String(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_GenerateKeyPair((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58Str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + cipher__SecKey *arg3 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58Str",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_GenerateDeterministicKeyPair",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58Str', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPair', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; (&arg1)->cap = size; } - result = (GoUint32)SKY_base58_Hex2Base58Str(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg2 = &p->data; + } + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPair(arg1,(unsigned char (*)[33])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_GenerateAddressesInFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_DeterministicKeyPairIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoUint64 arg2 ; - PasswordReader__Handle arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - GoSlice_ temp4 ; + GoSlice arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + cipher__PubKey *arg3 = (cipher__PubKey *) 0 ; + cipher__SecKey *arg4 = (cipher__SecKey *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; GoUint32 result; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GenerateAddressesInFile",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_DeterministicKeyPairIterator",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateAddressesInFile', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DeterministicKeyPairIterator', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); - } else { - arg3 = *((PasswordReader__Handle *)(argp3)); - } + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg3 = &p->data; } - result = (GoUint32)SKY_cli_GenerateAddressesInFile(arg1,arg2,arg3,arg4); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg4 = &p->data; + } + result = (GoUint32)SKY_cipher_DeterministicKeyPairIterator(arg1,arg2,(unsigned char (*)[33])arg3,(unsigned char (*)[32])arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -9889,36 +9913,46 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GenerateAddressesInFile(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoInt arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJSON",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairs",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJSON', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairs', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; (&arg1)->cap = size; } - result = (GoUint32)SKY_cli_FormatAddressesAsJSON(arg1,arg2); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairs" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairs(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -9926,36 +9960,116 @@ SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJSON(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJoinedArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 ); + _v = SWIG_IsOK(res) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_0(self, args); + } + } + } + if (argc == 2) { + int _v; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 ); + _v = SWIG_IsOK(res) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(self, args); + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_cipher_GenerateDeterministicKeyPairs'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,cipher_SecKeys *)\n" + " SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,coin__UxArray *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoInt arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJoinedArray",&obj0)) SWIG_fail; + { + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairsSeed",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJoinedArray', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairsSeed', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; (&arg1)->cap = size; } - result = (GoUint32)SKY_cli_FormatAddressesAsJoinedArray(arg1,arg2); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairsSeed" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairsSeed(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -9963,232 +10077,220 @@ SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJoinedArray(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_cli_AddressesToStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_CheckSecKey",&obj0)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_AddressesToStrings",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddressesToStrings', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_cli_AddressesToStrings(arg1,arg2); + result = (GoUint32)SKY_cipher_CheckSecKey((unsigned char (*)[32])arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_NewBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - GoUint64 arg2 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; - Transactions__Handle arg4 ; - FeeCalculator *arg5 = (FeeCalculator *) 0 ; - Block__Handle *arg6 = (Block__Handle *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - FeeCalculator temp5 ; - Handle temp6 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_CheckSecKeyHash",&obj0,&obj1)) SWIG_fail; { - arg6 = &temp6; - } - if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_coin_NewBlock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewBlock" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); { void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_CheckSecKeyHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; + cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58BitcoinAddress",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj3, (long*)&arg4); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58BitcoinAddress', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - { - if (!PyCallable_Check(obj4)) SWIG_fail; - temp5.callback = _WrapperFeeCalculator; - temp5.context = obj4; - arg5 = &temp5; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58BitcoinAddress" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); } - result = (GoUint32)SKY_coin_NewBlock(arg1,arg2,(unsigned char (*)[32])arg3,arg4,arg5,arg6); + arg2 = (cipher__BitcoinAddress *)(argp2); + result = (GoUint32)SKY_cipher_DecodeBase58BitcoinAddress(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_SignedBlock_VerifySignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__SignedBlock *arg1 = (coin__SignedBlock *) 0 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SignedBlock_VerifySignature",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__SignedBlock, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SignedBlock_VerifySignature" "', argument " "1"" of type '" "coin__SignedBlock *""'"); - } - arg1 = (coin__SignedBlock *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromPubKey",&obj0,&obj1)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + arg1 = &p->data; } - result = (GoUint32)SKY_coin_SignedBlock_VerifySignature(arg1,(unsigned char (*)[33])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromPubKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); + } + arg2 = (cipher__BitcoinAddress *)(argp2); + SKY_cipher_BitcoinAddressFromPubKey((unsigned char (*)[33])arg1,arg2); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_NewGenesisBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - GoUint64 arg2 ; - GoUint64 arg3 ; - Block__Handle *arg4 = (Block__Handle *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned long long val3 ; - int ecode3 = 0 ; - Handle temp4 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromSecKey",&obj0,&obj1)) SWIG_fail; { - arg4 = &temp4; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewGenesisBlock",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "1"" of type '" "cipher__Address *""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromSecKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); } - arg1 = (cipher__Address *)(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "3"" of type '" "GoUint64""'"); - } - arg3 = (GoUint64)(val3); - result = (GoUint32)SKY_coin_NewGenesisBlock(arg1,arg2,arg3,arg4); + arg2 = (cipher__BitcoinAddress *)(argp2); + result = (GoUint32)SKY_cipher_BitcoinAddressFromSecKey((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashHeader",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinWalletImportFormatFromSeckey",&obj0)) SWIG_fail; { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; + } + SKY_cipher_BitcoinWalletImportFormatFromSeckey((unsigned char (*)[32])arg1,arg2); + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - result = (GoUint32)SKY_coin_Block_HashHeader(arg1,(unsigned char (*)[32])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_PreHashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + GoSlice arg1 ; + cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_PreHashHeader",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromBytes",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_BitcoinAddressFromBytes', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromBytes" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); } - result = (GoUint32)SKY_coin_Block_PreHashHeader(arg1,(unsigned char (*)[32])arg2); + arg2 = (cipher__BitcoinAddress *)(argp2); + result = (GoUint32)SKY_cipher_BitcoinAddressFromBytes(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -10196,135 +10298,150 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Block_PreHashHeader(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + GoString arg1 ; + cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromBitcoinWalletImportFormat",&obj0,&obj1)) SWIG_fail; { - temp2 = 0; - arg2 = &temp2; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromBitcoinWalletImportFormat', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Time",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_coin_Block_Time(arg1,arg2); + result = (GoUint32)SKY_cipher_SecKeyFromBitcoinWalletImportFormat(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_Seq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; - GoUint32 result; + GoUint8 result; - { - temp2 = 0; - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Seq",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_coin_Block_Seq(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Null",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Null" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); } + arg1 = (cipher__BitcoinAddress *)(argp1); + result = (GoUint8)SKY_cipher_BitcoinAddress_Null(arg1); + resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashBody",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Bytes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Bytes" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); } + arg1 = (cipher__BitcoinAddress *)(argp1); + SKY_cipher_BitcoinAddress_Bytes(arg1,arg2); + resultobj = SWIG_Py_Void(); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } - result = (GoUint32)SKY_coin_Block_HashBody(arg1,(unsigned char (*)[32])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; + cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Size",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Verify",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Verify" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); + } + arg1 = (cipher__BitcoinAddress *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_coin_Block_Size(arg1,arg2); + result = (GoUint32)SKY_cipher_BitcoinAddress_Verify(arg1,(unsigned char (*)[33])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; + cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; GoString_ *arg2 = (GoString_ *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; GoString temp2 ; PyObject * obj0 = 0 ; - GoUint32 result; { temp2.p = NULL; temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_String",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_String",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_String" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); } - result = (GoUint32)SKY_coin_Block_String(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + arg1 = (cipher__BitcoinAddress *)(argp1); + SKY_cipher_BitcoinAddress_String(arg1,arg2); + resultobj = SWIG_Py_Void(); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); free( (void*)arg2->p ); @@ -10335,15 +10452,43 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Block_String(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_coin_Block_GetTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - Transaction__Handle *arg3 = (Transaction__Handle *) 0 ; - GoUint8 *arg4 = (GoUint8 *) 0 ; + cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + cipher__Checksum *arg2 = (cipher__Checksum *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Checksum",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Checksum" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); + } + arg1 = (cipher__BitcoinAddress *)(argp1); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum"); + cipher_Checksum* p = (cipher_Checksum*)argp; + arg2 = &p->data; + } + SKY_cipher_BitcoinAddress_Checksum(arg1,(unsigned char (*)[4])arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Transaction__Handle arg1 ; + GoSlice arg2 ; + CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ; Handle temp3 ; - GoUint8 temp4 ; - int res4 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; @@ -10351,116 +10496,118 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Block_GetTransaction(PyObject *SWIGUNUSEDPAR { arg3 = &temp3; } - arg4 = &temp4; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_GetTransaction",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreateTransactionResponse",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreateTransactionResponse', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_coin_Block_GetTransaction(arg1,(unsigned char (*)[32])arg2,arg3,arg4); + result = (GoUint32)SKY_api_NewCreateTransactionResponse(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } - if (SWIG_IsTmpObj(res4)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); - } else { - int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_NewBlockHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - GoUint64 arg3 ; - GoUint64 arg4 ; - BlockBody__Handle arg5 ; - coin__BlockHeader *arg6 = (coin__BlockHeader *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned long long val3 ; - int ecode3 = 0 ; - unsigned long long val4 ; - int ecode4 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + Transaction__Handle arg1 ; + GoSlice arg2 ; + CreatedTransaction__Handle *arg3 = (CreatedTransaction__Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_coin_NewBlockHeader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewBlockHeader" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + { + arg3 = &temp3; } - arg1 = (coin__BlockHeader *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransaction",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewBlockHeader" "', argument " "3"" of type '" "GoUint64""'"); - } - arg3 = (GoUint64)(val3); - ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_NewBlockHeader" "', argument " "4"" of type '" "GoUint64""'"); - } - arg4 = (GoUint64)(val4); { - SWIG_AsVal_long(obj4, (long*)&arg5); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreatedTransaction', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_coin_NewBlockHeader" "', argument " "6"" of type '" "coin__BlockHeader *""'"); + result = (GoUint32)SKY_api_NewCreatedTransaction(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } - arg6 = (coin__BlockHeader *)(argp6); - result = (GoUint32)SKY_coin_NewBlockHeader(arg1,(unsigned char (*)[32])arg2,arg3,arg4,arg5,arg6); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_CreatedTransaction_ToTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CreatedTransaction__Handle arg1 ; + Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; + Handle temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_CreatedTransaction_ToTransaction",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_CreatedTransaction_ToTransaction(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ; cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + CreatedTransactionOutput__Handle *arg3 = (CreatedTransactionOutput__Handle *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockHeader_Hash",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransactionOutput",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Hash" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionOutput" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); } - arg1 = (coin__BlockHeader *)(argp1); + arg1 = (coin__TransactionOutput *)(argp1); { void *argp = 0; int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); @@ -10469,41 +10616,40 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(se cipher_SHA256* p = (cipher_SHA256*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_coin_BlockHeader_Hash(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_api_NewCreatedTransactionOutput(arg1,(unsigned char (*)[32])arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; + wallet__UxBalance *arg1 = (wallet__UxBalance *) 0 ; + CreatedTransactionInput__Handle *arg2 = (CreatedTransactionInput__Handle *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - GoSlice_ temp2 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_Bytes",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewCreatedTransactionInput",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__UxBalance, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Bytes" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionInput" "', argument " "1"" of type '" "wallet__UxBalance *""'"); } - arg1 = (coin__BlockHeader *)(argp1); - result = (GoUint32)SKY_coin_BlockHeader_Bytes(arg1,arg2); + arg1 = (wallet__UxBalance *)(argp1); + result = (GoUint32)SKY_api_NewCreatedTransactionInput(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -10511,13 +10657,73 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Bytes(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + GoString_ *arg1 = (GoString_ *) 0 ; + GoString temp1 ; + GoUint32 result; + + { + temp1.p = NULL; + temp1.n = 0; + arg1 = (GoString_ *)&temp1; + } + if (!PyArg_ParseTuple(args,(char *)":SKY_iputil_LocalhostIP")) SWIG_fail; + result = (GoUint32)SKY_iputil_LocalhostIP(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); + free( (void*)arg1->p ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_iputil_IsLocalhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + GoUint32 result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_IsLocalhost",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_IsLocalhost', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; + } + result = (GoUint32)SKY_iputil_IsLocalhost(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_iputil_SplitAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; GoString_ *arg2 = (GoString_ *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + GoUint16 *arg3 = (GoUint16 *) 0 ; GoString temp2 ; + GoUint16 temp3 ; + int res3 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; GoUint32 result; @@ -10526,45 +10732,51 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_String(PyObject *SWIGUNUSEDPARM( temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_String",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_String" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_SplitAddr",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_SplitAddr', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - arg1 = (coin__BlockHeader *)(argp1); - result = (GoUint32)SKY_coin_BlockHeader_String(arg1,arg2); + result = (GoUint32)SKY_iputil_SplitAddr(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); free( (void*)arg2->p ); } + if (SWIG_IsTmpObj(res3)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); + } else { + int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_testutil_MakeAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - BlockBody__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockBody_Hash",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_testutil_MakeAddress",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_testutil_MakeAddress" "', argument " "1"" of type '" "cipher__Address *""'"); } - result = (GoUint32)SKY_coin_BlockBody_Hash(arg1,(unsigned char (*)[32])arg2); + arg1 = (cipher__Address *)(argp1); + result = (GoUint32)SKY_testutil_MakeAddress(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -10572,60 +10784,46 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - BlockBody__Handle *arg1 = (BlockBody__Handle *) 0 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; + Transaction__Handle *arg1 = (Transaction__Handle *) 0 ; Handle temp1 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; GoUint32 result; { arg1 = &temp1; } - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_BlockBody_Size")) SWIG_fail; - result = (GoUint32)SKY_coin_BlockBody_Size(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transaction")) SWIG_fail; + result = (GoUint32)SKY_coin_Create_Transaction(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); } - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - BlockBody__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + Transaction__Handle arg1 ; + Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockBody_Bytes",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Copy",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_BlockBody_Bytes(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_Copy(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -10633,38 +10831,26 @@ SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; - Transaction__Handle arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoSlice_ temp3 ; + Transaction__Handle arg1 ; + coin__Transaction **arg2 = (coin__Transaction **) 0 ; + coin__Transaction *temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_CreateUnspents",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspents" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + temp2 = NULL; + arg2 = &temp2; } - arg1 = (coin__BlockHeader *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetTransactionObject",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj1, (long*)&arg2); + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_CreateUnspents(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_GetTransactionObject(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Transaction, 0 )); } return resultobj; fail: @@ -10672,94 +10858,26 @@ SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_CreateUnspents__SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_CreateUnspents__SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_CreateUnspents'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin_UxOutArray *)\n" - " SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin__UxArray *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetInputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; - Transaction__Handle arg2 ; - GoInt arg3 ; - coin__UxOut *arg4 = (coin__UxOut *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - long long val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + long long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_CreateUnspent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspent" "', argument " "1"" of type '" "coin__BlockHeader *""'"); - } - arg1 = (coin__BlockHeader *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetInputs",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj1, (long*)&arg2); + SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_CreateUnspent" "', argument " "3"" of type '" "GoInt""'"); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetInputs" "', argument " "2"" of type '" "GoInt""'"); } - arg3 = (GoInt)(val3); - res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SKY_coin_CreateUnspent" "', argument " "4"" of type '" "coin__UxOut *""'"); - } - arg4 = (coin__UxOut *)(argp4); - result = (GoUint32)SKY_coin_CreateUnspent(arg1,arg2,arg3,arg4); + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_coin_Transaction_ResetInputs(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -10767,26 +10885,27 @@ SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspent(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - coin__Block **arg2 = (coin__Block **) 0 ; - coin__Block *temp2 ; + Transaction__Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; GoUint32 result; - { - temp2 = NULL; - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockObject",&obj0)) SWIG_fail; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetInputsCount",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_GetBlockObject(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_GetInputsCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Block, 0 )); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } return resultobj; fail: @@ -10794,189 +10913,201 @@ SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Block__Handle arg1 ; - BlockBody__Handle *arg2 = (BlockBody__Handle *) 0 ; - Handle temp2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + long long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockBody",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetInputAt",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_GetBlockBody(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetInputAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_coin_Transaction_GetInputAt(arg1,arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_NewEmptyBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle arg1 ; - Block__Handle *arg2 = (Block__Handle *) 0 ; - Handle temp2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + long long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_NewEmptyBlock",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetInputAt",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_NewEmptyBlock(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetInputAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_coin_Transaction_SetInputAt(arg1,arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Address *arg1 = (httphelper__Address *) 0 ; - GoSlice arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; + Transaction__Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_httphelper_Address_UnmarshalJSON",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_UnmarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); - } - arg1 = (httphelper__Address *)(argp1); + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetOutputsCount",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Address_UnmarshalJSON', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_httphelper_Address_UnmarshalJSON(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_GetOutputsCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Address *arg1 = (httphelper__Address *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoSlice_ temp2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ; + long long val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Address_MarshalJSON",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_MarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); } - arg1 = (httphelper__Address *)(argp1); - result = (GoUint32)SKY_httphelper_Address_MarshalJSON(arg1,arg2); + arg3 = (coin__TransactionOutput *)(argp3); + result = (GoUint32)SKY_coin_Transaction_GetOutputAt(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; - GoSlice arg2 ; - GoUint64 temp1 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ; + long long val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Coins_UnmarshalJSON",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Coins_UnmarshalJSON', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); } - result = (GoUint32)SKY_httphelper_Coins_UnmarshalJSON(arg1,arg2); + arg3 = (coin__TransactionOutput *)(argp3); + result = (GoUint32)SKY_coin_Transaction_SetOutputAt(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoUint64 temp1 ; - GoSlice_ temp2 ; + Transaction__Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetSignaturesCount",&obj0)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; - } - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_MarshalJSON")) SWIG_fail; - result = (GoUint32)SKY_httphelper_Coins_MarshalJSON(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_GetSignaturesCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } return resultobj; fail: @@ -10984,170 +11115,155 @@ SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_MarshalJSON(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp1 ; - GoUint64 temp2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + cipher__Sig *arg3 = (cipher__Sig *) 0 ; + long long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetSignatureAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); { - temp2 = 0; - arg2 = &temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg3 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_Value")) SWIG_fail; - result = (GoUint32)SKY_httphelper_Coins_Value(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_GetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; - GoSlice arg2 ; - GoUint64 temp1 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + cipher__Sig *arg3 = (cipher__Sig *) 0 ; + long long val2 ; + int ecode2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Hours_UnmarshalJSON",&obj0)) SWIG_fail; + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetSignatureAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Hours_UnmarshalJSON', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg3 = &p->data; } - result = (GoUint32)SKY_httphelper_Hours_UnmarshalJSON(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_SetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushSignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoUint64 temp1 ; - GoSlice_ temp2 ; + Transaction__Handle arg1 ; + cipher__Sig *arg2 = (cipher__Sig *) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushSignature",&obj0,&obj1)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); + cipher_Sig* p = (cipher_Sig*)argp; + arg2 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_MarshalJSON")) SWIG_fail; - result = (GoUint32)SKY_httphelper_Hours_MarshalJSON(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_PushSignature(arg1,(unsigned char (*)[65])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp1 ; - GoUint64 temp2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + long long val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetOutputs",&obj0,&obj1)) SWIG_fail; { - temp1 = 0; - arg1 = &temp1; - } - { - temp2 = 0; - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_Value")) SWIG_fail; - result = (GoUint32)SKY_httphelper_Hours_Value(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + SWIG_AsVal_long(obj0, (long*)&arg1); } + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetOutputs" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_coin_Transaction_ResetOutputs(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetSignatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint64 arg2 ; - wallet__Balance *arg3 = (wallet__Balance *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned long long val2 ; + Transaction__Handle arg1 ; + GoInt arg2 ; + long long val2 ; int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalance",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalance" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetSignatures",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_NewBalance" "', argument " "2"" of type '" "GoUint64""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetSignatures" "', argument " "2"" of type '" "GoInt""'"); } - arg2 = (GoUint64)(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalance" "', argument " "3"" of type '" "wallet__Balance *""'"); - } - arg3 = (wallet__Balance *)(argp3); - result = (GoUint32)SKY_wallet_NewBalance(arg1,arg2,arg3); + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_coin_Transaction_ResetSignatures(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -11155,39 +11271,17 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalanceFromUxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - coin__UxOut *arg2 = (coin__UxOut *) 0 ; - wallet__Balance *arg3 = (wallet__Balance *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Transaction__Handle arg1 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalanceFromUxOut",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "2"" of type '" "coin__UxOut *""'"); - } - arg2 = (coin__UxOut *)(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "3"" of type '" "wallet__Balance *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Verify",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg3 = (wallet__Balance *)(argp3); - result = (GoUint32)SKY_wallet_NewBalanceFromUxOut(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_Verify(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -11195,120 +11289,112 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalanceFromUxOut(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__Balance *arg1 = (wallet__Balance *) 0 ; - wallet__Balance *arg2 = (wallet__Balance *) 0 ; - wallet__Balance *arg3 = (wallet__Balance *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Transaction__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Add",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Add" "', argument " "1"" of type '" "wallet__Balance *""'"); - } - arg1 = (wallet__Balance *)(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Add" "', argument " "2"" of type '" "wallet__Balance *""'"); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - arg2 = (wallet__Balance *)(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Add" "', argument " "3"" of type '" "wallet__Balance *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_VerifyInput",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg3 = (wallet__Balance *)(argp3); - result = (GoUint32)SKY_wallet_Balance_Add(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_VerifyInput(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - wallet__Balance *arg1 = (wallet__Balance *) 0 ; - wallet__Balance *arg2 = (wallet__Balance *) 0 ; - wallet__Balance *arg3 = (wallet__Balance *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Sub",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Sub" "', argument " "1"" of type '" "wallet__Balance *""'"); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - arg1 = (wallet__Balance *)(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Sub" "', argument " "2"" of type '" "wallet__Balance *""'"); + if (argc == 1) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(self, args); + } } - arg2 = (wallet__Balance *)(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Sub" "', argument " "3"" of type '" "wallet__Balance *""'"); + if (argc == 2) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_0(self, args); + } + } } - arg3 = (wallet__Balance *)(argp3); - result = (GoUint32)SKY_wallet_Balance_Sub(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_VerifyInput'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin_UxOutArray *)\n" + " SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__Balance *arg1 = (wallet__Balance *) 0 ; - wallet__Balance *arg2 = (wallet__Balance *) 0 ; - GoUint8 *arg3 = (GoUint8 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - GoUint8 temp3 ; + Transaction__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + GoUint16 *arg3 = (GoUint16 *) 0 ; + GoUint16 temp3 ; int res3 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; arg3 = &temp3; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Balance_Equals",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Equals" "', argument " "1"" of type '" "wallet__Balance *""'"); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushInput",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg1 = (wallet__Balance *)(argp1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Equals" "', argument " "2"" of type '" "wallet__Balance *""'"); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - arg2 = (wallet__Balance *)(argp2); - result = (GoUint32)SKY_wallet_Balance_Equals(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_PushInput(arg1,(unsigned char (*)[32])arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); if (SWIG_IsTmpObj(res3)) { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); } else { int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags)); } return resultobj; fail: @@ -11316,83 +11402,102 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Equals(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_IsZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_TransactionOutput_UxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__Balance *arg1 = (wallet__Balance *) 0 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; + coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Balance_IsZero",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_TransactionOutput_UxID",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_IsZero" "', argument " "1"" of type '" "wallet__Balance *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_TransactionOutput_UxID" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); } - arg1 = (wallet__Balance *)(argp1); - result = (GoUint32)SKY_wallet_Balance_IsZero(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + arg1 = (coin__TransactionOutput *)(argp1); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; + } + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_coin_TransactionOutput_UxID(arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_CryptoTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Transaction__Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + GoUint64 arg3 ; + GoUint64 arg4 ; + void *argp2 = 0 ; + int res2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + unsigned long long val4 ; + int ecode4 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_Transaction_PushOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_CryptoTypeFromString",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CryptoTypeFromString', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "2"" of type '" "cipher__Address *""'"); } - result = (GoUint32)SKY_wallet_CryptoTypeFromString(arg1,arg2); + arg2 = (cipher__Address *)(argp2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "4"" of type '" "GoUint64""'"); + } + arg4 = (GoUint64)(val4); + result = (GoUint32)SKY_coin_Transaction_PushOutput(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString arg2 ; + Transaction__Handle arg1 ; + GoSlice arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_AddPrivateKey",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SignInputs",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -11401,12 +11506,13 @@ SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKey', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_Transaction_SignInputs', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_cli_AddPrivateKey(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_SignInputs(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -11414,90 +11520,80 @@ SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKeyToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoString arg1 ; - GoString arg2 ; - PasswordReader__Handle arg3 ; - void *argp3 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_AddPrivateKeyToFile",&obj0,&obj1,&obj2)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string"); + if (argc == 2) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( argv[1], &buffer, &size, 0 ); + _v = SWIG_IsOK(res) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transaction_SignInputs__SWIG_1(self, args); + } } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; } - { - res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); - } else { - arg3 = *((PasswordReader__Handle *)(argp3)); + if (argc == 2) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transaction_SignInputs__SWIG_0(self, args); + } } } - result = (GoUint32)SKY_cli_AddPrivateKeyToFile(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_SignInputs'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_Transaction_SignInputs(Transaction__Handle,cipher_SecKeys *)\n" + " SKY_coin_Transaction_SignInputs(Transaction__Handle,GoSlice)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Transaction__Handle arg1 ; - GoSlice arg2 ; - CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ; - Handle temp3 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreateTransactionResponse",&obj0,&obj1)) SWIG_fail; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Size",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreateTransactionResponse', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; - } - result = (GoUint32)SKY_api_NewCreateTransactionResponse(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_Size(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -11505,64 +11601,65 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreateTransactionResponse(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Transaction__Handle arg1 ; - GoSlice arg2 ; - CreatedTransaction__Handle *arg3 = (CreatedTransaction__Handle *) 0 ; - Handle temp3 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransaction",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_Hash",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewCreatedTransaction', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_NewCreatedTransaction(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_Hash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_CreatedTransaction_ToTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SizeHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - CreatedTransaction__Handle arg1 ; - Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; - Handle temp2 ; + Transaction__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SizeHash",&obj0,&obj1)) SWIG_fail; { - arg2 = &temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_CreatedTransaction_ToTransaction",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } - result = (GoUint32)SKY_api_CreatedTransaction_ToTransaction(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_SizeHash(arg1,arg2,(unsigned char (*)[32])arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -11570,39 +11667,29 @@ SWIGINTERN PyObject *_wrap_SKY_api_CreatedTransaction_ToTransaction(PyObject *SW } -SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - CreatedTransactionOutput__Handle *arg3 = (CreatedTransactionOutput__Handle *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Handle temp3 ; + Transaction__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_NewCreatedTransactionOutput",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionOutput" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - arg1 = (coin__TransactionOutput *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxID",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_NewCreatedTransactionOutput(arg1,(unsigned char (*)[32])arg2,arg3); + result = (GoUint32)SKY_coin_Transaction_TxID(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -11610,29 +11697,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionOutput(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxIDHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__UxBalance *arg1 = (wallet__UxBalance *) 0 ; - CreatedTransactionInput__Handle *arg2 = (CreatedTransactionInput__Handle *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Handle temp2 ; + Transaction__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewCreatedTransactionInput",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__UxBalance, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_api_NewCreatedTransactionInput" "', argument " "1"" of type '" "wallet__UxBalance *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxIDHex",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg1 = (wallet__UxBalance *)(argp1); - result = (GoUint32)SKY_api_NewCreatedTransactionInput(arg1,arg2); + result = (GoUint32)SKY_coin_Transaction_TxIDHex(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -11640,12 +11726,17 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewCreatedTransactionInput(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_logging_EnableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_UpdateHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; + Transaction__Handle arg1 ; + PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_logging_EnableColors")) SWIG_fail; - result = (GoUint32)SKY_logging_EnableColors(); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_UpdateHeader",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_coin_Transaction_UpdateHeader(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -11653,12 +11744,27 @@ SWIGINTERN PyObject *_wrap_SKY_logging_EnableColors(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_logging_DisableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_HashInner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; + Transaction__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_logging_DisableColors")) SWIG_fail; - result = (GoUint32)SKY_logging_DisableColors(); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_HashInner",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; + } + result = (GoUint32)SKY_coin_Transaction_HashInner(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -11666,48 +11772,63 @@ SWIGINTERN PyObject *_wrap_SKY_logging_DisableColors(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_logging_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; + Transaction__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; + PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_logging_Disable")) SWIG_fail; - result = (GoUint32)SKY_logging_Disable(); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Serialize",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_coin_Transaction_Serialize(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_TransactionDeserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoSlice arg1 ; + Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_InitDataDir",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_TransactionDeserialize",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_InitDataDir', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_TransactionDeserialize', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_file_InitDataDir(arg1,arg2); + result = (GoUint32)SKY_coin_TransactionDeserialize(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -11715,23 +11836,26 @@ SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_OutputHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString_ *arg1 = (GoString_ *) 0 ; - GoString temp1 ; + Transaction__Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; + PyObject * obj0 = 0 ; GoUint32 result; { - temp1.p = NULL; - temp1.n = 0; - arg1 = (GoString_ *)&temp1; + temp2 = 0; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)":SKY_file_UserHome")) SWIG_fail; - result = (GoUint32)SKY_file_UserHome(arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_OutputHours",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_coin_Transaction_OutputHours(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); - free( (void*)arg1->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -11739,35 +11863,20 @@ SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_SKY_file_ResolveResourceDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; - PyObject * obj0 = 0 ; + Transactions__Handle *arg1 = (Transactions__Handle *) 0 ; + Handle temp1 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_ResolveResourceDirectory",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_ResolveResourceDirectory', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + arg1 = &temp1; } - result = (GoUint32)SKY_file_ResolveResourceDirectory(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transactions")) SWIG_fail; + result = (GoUint32)SKY_coin_Create_Transactions(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); } return resultobj; fail: @@ -11775,179 +11884,54 @@ SWIGINTERN PyObject *_wrap_SKY_file_ResolveResourceDirectory(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_file_DetermineResourcePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionsObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString arg2 ; - GoString arg3 ; - GoString_ *arg4 = (GoString_ *) 0 ; - GoString temp4 ; + Transactions__Handle arg1 ; + coin__UxArray **arg2 = (coin__UxArray **) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_GetTransactionsObject",&obj0,&obj1)) SWIG_fail; { - temp4.p = NULL; - temp4.n = 0; - arg4 = (GoString_ *)&temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_file_DetermineResourcePath",&obj0,&obj1,&obj2)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GoSlice_, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_GetTransactionsObject" "', argument " "2"" of type '" "coin__UxArray **""'"); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; - } - result = (GoUint32)SKY_file_DetermineResourcePath(arg1,arg2,arg3,arg4); + arg2 = (coin__UxArray **)(argp2); + result = (GoUint32)SKY_coin_GetTransactionsObject(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); - free( (void*)arg4->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_CreateOptionsHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString arg2 ; - GoString arg3 ; - GoUint8 arg4 ; - GoString arg5 ; - GoString arg6 ; - GoUint64 arg7 ; - Options__Handle *arg8 = (Options__Handle *) 0 ; - unsigned char val4 ; - int ecode4 = 0 ; - unsigned long long val7 ; - int ecode7 = 0 ; - Handle temp8 ; + Transactions__Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; - PyObject * obj6 = 0 ; - GoUint32 result; - - { - arg8 = &temp8; - } - if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SKY_wallet_CreateOptionsHandle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; - } - ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "4"" of type '" "GoUint8""'"); - } - arg4 = (GoUint8)(val4); - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); - } - (&arg5)->p = buffer; - (&arg5)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); - } - (&arg6)->p = buffer; - (&arg6)->n = size - 1; - } - ecode7 = SWIG_AsVal_unsigned_SS_long_SS_long(obj6, &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "7"" of type '" "GoUint64""'"); - } - arg7 = (GoUint64)(val7); - result = (GoUint32)SKY_wallet_CreateOptionsHandle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg8)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_cli_LoadConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Config__Handle *arg1 = (Config__Handle *) 0 ; - Handle temp1 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Length",&obj0)) SWIG_fail; { - arg1 = &temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)":SKY_cli_LoadConfig")) SWIG_fail; - result = (GoUint32)SKY_cli_LoadConfig(arg1); + result = (GoUint32)SKY_coin_Transactions_Length(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } return resultobj; fail: @@ -11955,83 +11939,58 @@ SWIGINTERN PyObject *_wrap_SKY_cli_LoadConfig(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullWalletPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Config__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Transactions__Handle arg1 ; + Transaction__Handle arg2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullWalletPath",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Add",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_Config_FullWalletPath(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + SWIG_AsVal_long(obj1, (long*)&arg2); } + result = (GoUint32)SKY_coin_Transactions_Add(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullDBPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Config__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Transactions__Handle arg1 ; + FeeCalculator *arg2 = (FeeCalculator *) 0 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + FeeCalculator temp2 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3 = 0; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullDBPath",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Fees",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_Config_FullDBPath(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Config__Handle arg1 ; - App__Handle *arg2 = (App__Handle *) 0 ; - Handle temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; - { + if (!PyCallable_Check(obj1)) SWIG_fail; + temp2.callback = _WrapperFeeCalculator; + temp2.context = obj1; arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_NewApp",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_cli_NewApp(arg1,arg2); + result = (GoUint32)SKY_coin_Transactions_Fees(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); } return resultobj; fail: @@ -12039,25 +11998,34 @@ SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Context__Handle arg1 ; - WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; - Handle temp2 ; + Transactions__Handle arg1 ; + GoInt arg2 ; + Transaction__Handle *arg3 = (Transaction__Handle *) 0 ; + long long val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromContext",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_GetAt",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_RPCClientFromContext(arg1,arg2); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_GetAt" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_coin_Transactions_GetAt(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -12065,25 +12033,29 @@ SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Context__Handle arg1 ; - Config__Handle *arg2 = (Config__Handle *) 0 ; - Handle temp2 ; + Transactions__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_ConfigFromContext",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Hashes",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_ConfigFromContext(arg1,arg2); + result = (GoUint32)SKY_coin_Transactions_Hashes(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -12091,61 +12063,67 @@ SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromBytes_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; - GoSlice_ temp2 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromBytes_Password")) SWIG_fail; - result = (GoUint32)SKY_cli_PasswordFromBytes_Password(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); + if (argc == 1) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transactions_Hashes__SWIG_0(self, args); + } } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + if (argc == 1) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_Transactions_Hashes__SWIG_1(self, args); + } } - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transactions_Hashes'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_Transactions_Hashes(Transactions__Handle,cipher_SHA256s *)\n" + " SKY_coin_Transactions_Hashes(Transactions__Handle,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; + Transactions__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Size",&obj0)) SWIG_fail; { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromTerm_Password")) SWIG_fail; - result = (GoUint32)SKY_cli_PasswordFromTerm_Password(arg1); + result = (GoUint32)SKY_coin_Transactions_Size(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -12153,95 +12131,105 @@ SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_TruncateBytesTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxOut *arg1 = (coin__UxOut *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Transactions__Handle arg1 ; + GoUint32 arg2 ; + Transactions__Handle *arg3 = (Transactions__Handle *) 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_Hash",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_Hash" "', argument " "1"" of type '" "coin__UxOut *""'"); + { + arg3 = &temp3; } - arg1 = (coin__UxOut *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_TruncateBytesTo",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_UxOut_Hash(arg1,(unsigned char (*)[32])arg2); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_TruncateBytesTo" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + result = (GoUint32)SKY_coin_Transactions_TruncateBytesTo(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_SnapshotHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxOut *arg1 = (coin__UxOut *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Transactions__Handle arg1 ; + FeeCalculator *arg2 = (FeeCalculator *) 0 ; + Transactions__Handle *arg3 = (Transactions__Handle *) 0 ; + FeeCalculator temp2 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_SnapshotHash",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_SnapshotHash" "', argument " "1"" of type '" "coin__UxOut *""'"); + { + arg3 = &temp3; } - arg1 = (coin__UxOut *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SortTransactions",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_UxOut_SnapshotHash(arg1,(unsigned char (*)[32])arg2); + { + if (!PyCallable_Check(obj1)) SWIG_fail; + temp2.callback = _WrapperFeeCalculator; + temp2.context = obj1; + arg2 = &temp2; + } + result = (GoUint32)SKY_coin_SortTransactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_UxBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_NewSortableTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxBody *arg1 = (coin__UxBody *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Transactions__Handle arg1 ; + FeeCalculator *arg2 = (FeeCalculator *) 0 ; + SortableTransactionResult_Handle *arg3 = (SortableTransactionResult_Handle *) 0 ; + FeeCalculator temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxBody_Hash",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxBody, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxBody_Hash" "', argument " "1"" of type '" "coin__UxBody *""'"); + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewSortableTransactions",&obj0,&obj1,&obj2)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg1 = (coin__UxBody *)(argp1); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + if (!PyCallable_Check(obj1)) SWIG_fail; + temp2.callback = _WrapperFeeCalculator; + temp2.context = obj1; + arg2 = &temp2; } - result = (GoUint32)SKY_coin_UxBody_Hash(arg1,(unsigned char (*)[32])arg2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_SortableTransactionResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_NewSortableTransactions" "', argument " "3"" of type '" "SortableTransactionResult_Handle *""'"); + } + arg3 = (SortableTransactionResult_Handle *)(argp3); + result = (GoUint32)SKY_coin_NewSortableTransactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -12249,76 +12237,65 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxBody_Hash(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_CoinHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxOut *arg1 = (coin__UxOut *) 0 ; - GoUint64 arg2 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - void *argp1 = 0 ; + SortableTransactionResult_Handle arg1 ; + void *argp1 ; int res1 = 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - GoUint64 temp3 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Sort",&obj0)) SWIG_fail; { - temp3 = 0; - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_CoinHours",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "1"" of type '" "coin__UxOut *""'"); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } else { + arg1 = *((SortableTransactionResult_Handle *)(argp1)); + } } - arg1 = (coin__UxOut *)(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_coin_UxOut_CoinHours(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_SortableTransactions_Sort(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; - GoSlice_ temp2 ; + SortableTransactionResult_Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + void *argp1 ; + int res1 = 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Len",&obj0)) SWIG_fail; { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } else { + arg1 = *((SortableTransactionResult_Handle *)(argp1)); + } } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Hashes")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Hashes(arg1,arg2); + result = (GoUint32)SKY_coin_SortableTransactions_Len(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } return resultobj; fail: @@ -12326,47 +12303,114 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Less(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SortableTransactionResult_Handle arg1 ; + GoInt arg2 ; + GoInt arg3 ; + GoUint8 *arg4 = (GoUint8 *) 0 ; + void *argp1 ; + int res1 = 0 ; + long long val2 ; + int ecode2 = 0 ; + long long val3 ; + int ecode3 = 0 ; + GoUint8 temp4 ; + int res4 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + GoUint32 result; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); + arg4 = &temp4; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Less",&obj0,&obj1,&obj2)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } else { + arg1 = *((SortableTransactionResult_Handle *)(argp1)); + } } - if (argc == 0) { - return _wrap_SKY_coin_UxArray_Hashes__SWIG_1(self, args); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "3"" of type '" "GoInt""'"); + } + arg3 = (GoInt)(val3); + result = (GoUint32)SKY_coin_SortableTransactions_Less(arg1,arg2,arg3,arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res4)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); + } else { + int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); } - if (argc == 1) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_UxArray_Hashes__SWIG_0(self, args); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + SortableTransactionResult_Handle arg1 ; + GoInt arg2 ; + GoInt arg3 ; + void *argp1 ; + int res1 = 0 ; + long long val2 ; + int ecode2 = 0 ; + long long val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Swap",&obj0,&obj1,&obj2)) SWIG_fail; + { + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); + } else { + arg1 = *((SortableTransactionResult_Handle *)(argp1)); } } - + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "3"" of type '" "GoInt""'"); + } + arg3 = (GoInt)(val3); + result = (GoUint32)SKY_coin_SortableTransactions_Swap(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Hashes'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Hashes(coin_UxOutArray *,cipher_SHA256s *)\n" - " SKY_coin_UxArray_Hashes(coin__UxArray *,coin__UxArray *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; GoSlice_ temp1 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + GoSlice_ temp2 ; GoUint32 result; { @@ -12375,19 +12419,22 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSE temp1.cap = 0; arg1 = (coin__UxArray *)&temp1; } - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_HasDupes")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_HasDupes(arg1,arg2); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_VerifyTransactionCoinsSpending")) SWIG_fail; + result = (GoUint32)SKY_coin_VerifyTransactionCoinsSpending(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); free( (void*)arg1->data ); } - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -12395,58 +12442,84 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { + for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 0) { - return _wrap_SKY_coin_UxArray_HasDupes__SWIG_1(self, args); + return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(self, args); } - if (argc == 1) { + if (argc == 2) { int _v; { _v = PyList_Check(argv[0]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_UxArray_HasDupes__SWIG_0(self, args); + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_0(self, args); + } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_HasDupes'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionCoinsSpending'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_HasDupes(coin_UxOutArray *,GoUint8 *)\n" - " SKY_coin_UxArray_HasDupes(coin__UxArray *,GoUint8 *)\n"); + " wrap_SKY_coin_VerifyTransactionCoinsSpending(coin_UxOutArray *,coin_UxOutArray *)\n" + " SKY_coin_VerifyTransactionCoinsSpending(coin__UxArray *,coin__UxArray *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; + GoUint64 arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + GoSlice_ temp2 ; + GoSlice_ temp3 ; + PyObject * obj0 = 0 ; GoUint32 result; { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sort")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Sort(arg1); + { + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_VerifyTransactionHoursSpending",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_VerifyTransactionHoursSpending" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + result = (GoUint32)SKY_coin_VerifyTransactionHoursSpending(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -12454,615 +12527,111 @@ SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sort(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoInt *arg2 = (GoInt *) 0 ; - GoSlice_ temp1 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Len")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Len(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoInt arg2 ; - GoInt arg3 ; - GoUint8 *arg4 = (GoUint8 *) 0 ; - GoSlice_ temp1 ; - long long val2 ; - int ecode2 = 0 ; - long long val3 ; - int ecode3 = 0 ; - GoUint8 temp4 ; - int res4 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - arg4 = &temp4; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Less",&obj0,&obj1)) SWIG_fail; - ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Less" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Less" "', argument " "3"" of type '" "GoInt""'"); - } - arg3 = (GoInt)(val3); - result = (GoUint32)SKY_coin_UxArray_Less(arg1,arg2,arg3,arg4); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - if (SWIG_IsTmpObj(res4)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); - } else { - int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_long_SS_long(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_Less__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_Less__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Less'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Less(coin_UxOutArray *,GoInt,GoInt,GoUint8 *)\n" - " SKY_coin_UxArray_Less(coin__UxArray *,GoInt,GoInt,GoUint8 *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoInt arg2 ; - GoInt arg3 ; - GoSlice_ temp1 ; - long long val2 ; - int ecode2 = 0 ; - long long val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Swap",&obj0,&obj1)) SWIG_fail; - ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Swap" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Swap" "', argument " "3"" of type '" "GoInt""'"); - } - arg3 = (GoInt)(val3); - result = (GoUint32)SKY_coin_UxArray_Swap(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_long_SS_long(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_Swap__SWIG_1(self, args); - } - } - } - if (argc == 3) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_Swap__SWIG_0(self, args); - } - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Swap'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Swap(coin_UxOutArray *,GoInt,GoInt)\n" - " SKY_coin_UxArray_Swap(coin__UxArray *,GoInt,GoInt)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoSlice_ temp1 ; - GoUint64 temp2 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp2 = 0; - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Coins")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Coins(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_SKY_coin_UxArray_Coins__SWIG_1(self, args); - } - if (argc == 1) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_UxArray_Coins__SWIG_0(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Coins'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Coins(coin_UxOutArray *,GoUint64 *)\n" - " SKY_coin_UxArray_Coins(coin__UxArray *,GoUint64 *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - GoUint64 arg2 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - GoSlice_ temp1 ; - unsigned long long val2 ; - int ecode2 = 0 ; - GoUint64 temp3 ; - PyObject * obj0 = 0 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp3 = 0; - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_UxArray_CoinHours",&obj0)) SWIG_fail; - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_CoinHours" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_coin_UxArray_CoinHours(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_CoinHours__SWIG_1(self, args); - } - } - if (argc == 2) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_coin_UxArray_CoinHours__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_CoinHours'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_CoinHours(coin_UxOutArray *,GoUint64,GoUint64 *)\n" - " SKY_coin_UxArray_CoinHours(coin__UxArray *,GoUint64,GoUint64 *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; - GoSlice_ temp2 ; - GoSlice_ temp3 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sub")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Sub(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_SKY_coin_UxArray_Sub__SWIG_1(self, args); - } - if (argc == 2) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_UxArray_Sub__SWIG_0(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Sub'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Sub(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n" - " SKY_coin_UxArray_Sub(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; - GoSlice_ temp2 ; - GoSlice_ temp3 ; - GoUint32 result; - - { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; - } - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Add")) SWIG_fail; - result = (GoUint32)SKY_coin_UxArray_Add(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { + for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 0) { - return _wrap_SKY_coin_UxArray_Add__SWIG_1(self, args); + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(self, args); + } } - if (argc == 2) { + if (argc == 3) { int _v; { - _v = PyList_Check(argv[0]) ? 1 : 0; + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); } if (_v) { { _v = PyList_Check(argv[1]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_UxArray_Add__SWIG_0(self, args); + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_0(self, args); + } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Add'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionHoursSpending'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_UxArray_Add(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n" - " SKY_coin_UxArray_Add(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n"); + " wrap_SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin_UxOutArray *,coin_UxOutArray *)\n" + " SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin__UxArray *,coin__UxArray *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - AddressUxOuts_Handle *arg2 = (AddressUxOuts_Handle *) 0 ; - GoSlice_ temp1 ; - Handle temp2 ; + encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ; + GoSlice arg2 ; + GoSlice arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoSlice_ temp4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; + } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Encrypt",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Encrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); } + arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1); { - arg2 = &temp2; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_NewAddressUxOuts")) SWIG_fail; - result = (GoUint32)SKY_coin_NewAddressUxOuts(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string"); + } + (&arg3)->data = buffer; + (&arg3)->len = size - 1; + (&arg3)->cap = size; } + result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Encrypt(arg1,arg2,arg3,arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -13070,63 +12639,59 @@ SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 0) { - return _wrap_SKY_coin_NewAddressUxOuts__SWIG_1(self, args); - } - if (argc == 1) { - int _v; - { - _v = PyList_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_NewAddressUxOuts__SWIG_0(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_NewAddressUxOuts'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_NewAddressUxOuts(coin_UxOutArray *,AddressUxOuts_Handle *)\n" - " SKY_coin_NewAddressUxOuts(coin__UxArray *,AddressUxOuts_Handle *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ; + GoSlice arg2 ; + GoSlice arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Keys",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Decrypt",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Decrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); + } + arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_coin_AddressUxOuts_Keys(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string"); + } + (&arg3)->data = buffer; + (&arg3)->len = size - 1; + (&arg3)->cap = size; + } + result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Decrypt(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -13134,69 +12699,49 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_0(self, args); - } - } - if (argc == 1) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(self, args); - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Keys'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,cipher_Addresses *)\n" - " SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,coin__UxArray *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_GenerateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + GoString arg1 ; + Options__Handle *arg2 = (Options__Handle *) 0 ; + GoUint64 arg3 ; + Wallet__Handle *arg4 = (Wallet__Handle *) 0 ; + Handle temp2 ; + unsigned long long val3 ; + int ecode3 = 0 ; + Handle temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + arg2 = &temp2; + } + { + arg4 = &temp4; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GenerateWallet",&obj0,&obj1)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateWallet', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Flatten",&obj0)) SWIG_fail; + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_cli_GenerateWallet" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + result = (GoUint32)SKY_cli_GenerateWallet(arg1,arg2,arg3,arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - SWIG_AsVal_long(obj0, (long*)&arg1); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } - result = (GoUint32)SKY_coin_AddressUxOuts_Flatten(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); } return resultobj; fail: @@ -13204,140 +12749,142 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_SKY_cli_MakeAlphanumericSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString_ *arg1 = (GoString_ *) 0 ; + GoString temp1 ; + GoUint32 result; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 1) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 1) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_0(self, args); - } + { + temp1.p = NULL; + temp1.n = 0; + arg1 = (GoString_ *)&temp1; } - if (argc == 1) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(self, args); - } + if (!PyArg_ParseTuple(args,(char *)":SKY_cli_MakeAlphanumericSeed")) SWIG_fail; + result = (GoUint32)SKY_cli_MakeAlphanumericSeed(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); + free( (void*)arg1->p ); } - + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Flatten'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin_UxOutArray *)\n" - " SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin__UxArray *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - AddressUxOuts_Handle arg2 ; - AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Sub",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_AddPrivateKey",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } { - SWIG_AsVal_long(obj1, (long*)&arg2); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKey', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - result = (GoUint32)SKY_coin_AddressUxOuts_Sub(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_AddPrivateKey(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_AddPrivateKeyToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - AddressUxOuts_Handle arg2 ; - AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ; - Handle temp3 ; + GoString arg1 ; + GoString arg2 ; + PasswordReader__Handle arg3 ; + void *argp3 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_AddPrivateKeyToFile",&obj0,&obj1,&obj2)) SWIG_fail; { - arg3 = &temp3; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Add",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddPrivateKeyToFile', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } { - SWIG_AsVal_long(obj1, (long*)&arg2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_AddPrivateKeyToFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); + } else { + arg3 = *((PasswordReader__Handle *)(argp3)); + } } - result = (GoUint32)SKY_coin_AddressUxOuts_Add(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_AddPrivateKeyToFile(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_String2Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - GoSlice_ temp3 ; + GoString arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Get",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_String2Hex",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Get" "', argument " "2"" of type '" "cipher__Address *""'"); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_String2Hex', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_coin_AddressUxOuts_Get(arg1,arg2,arg3); + result = (GoUint32)SKY_base58_String2Hex(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -13345,86 +12892,34 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; - - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); - } - if (argc == 2) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_0(self, args); - } - } - } - if (argc == 2) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(self, args); - } - } - } - -fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Get'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n" - " SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - GoUint8 *arg3 = (GoUint8 *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - GoUint8 temp3 ; - int res3 = SWIG_TMPOBJ ; + GoString arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - - arg3 = &temp3; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_HasKey",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_HasKey" "', argument " "2"" of type '" "cipher__Address *""'"); + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToInt",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToInt', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_coin_AddressUxOuts_HasKey(arg1,arg2,arg3); + result = (GoUint32)SKY_base58_Base58_ToInt(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res3)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); } else { - int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags)); + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } return resultobj; fail: @@ -13432,36 +12927,36 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_HasKey(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_GetOutputLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Base58_ToHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - GoInt *arg3 = (GoInt *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - GoInt temp3 ; - int res3 = SWIG_TMPOBJ ; + GoString arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - arg3 = &temp3; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_GetOutputLength",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_GetOutputLength" "', argument " "2"" of type '" "cipher__Address *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_ToHex",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_ToHex', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_coin_AddressUxOuts_GetOutputLength(arg1,arg2,arg3); + result = (GoUint32)SKY_base58_Base58_ToHex(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res3)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); - } else { - int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -13469,9 +12964,9 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_GetOutputLength(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Base58_Base582Int(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; + GoString arg1 ; GoInt *arg2 = (GoInt *) 0 ; GoInt temp2 ; int res2 = SWIG_TMPOBJ ; @@ -13479,11 +12974,18 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPAR GoUint32 result; arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Length",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_Base582Int",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_Base582Int', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_coin_AddressUxOuts_Length(arg1,arg2); + result = (GoUint32)SKY_base58_Base58_Base582Int(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); if (SWIG_IsTmpObj(res2)) { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); @@ -13497,38 +12999,36 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Base582Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - AddressUxOuts_Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - GoSlice_ temp3 ; + GoString arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Set",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base582Hex",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Set" "', argument " "2"" of type '" "cipher__Address *""'"); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base582Hex', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_coin_AddressUxOuts_Set(arg1,arg2,arg3); + result = (GoUint32)SKY_base58_Base582Hex(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -13536,88 +13036,143 @@ SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_SKY_base58_Base58_BitHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (argc == 2) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(self, args); - } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Base58_BitHex",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Base58_BitHex', expecting string"); } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (argc == 3) { - int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_0(self, args); - } - } + result = (GoUint32)SKY_base58_Base58_BitHex(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_base58_Int2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoInt arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + long long val1 ; + int ecode1 = 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Int2Base58",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_base58_Int2Base58" "', argument " "1"" of type '" "GoInt""'"); + } + arg1 = (GoInt)(val1); + result = (GoUint32)SKY_base58_Int2Base58(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoSlice arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58', expecting string"); } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; + } + result = (GoUint32)SKY_base58_Hex2Base58(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Set'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n" - " SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_RandByte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoInt arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - long long val1 ; - int ecode1 = 0 ; - GoSlice_ temp2 ; + GoSlice arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_RandByte",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_cipher_RandByte" "', argument " "1"" of type '" "GoInt""'"); - } - arg1 = (GoInt)(val1); - result = (GoUint32)SKY_cipher_RandByte(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58String",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58String', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; + } + result = (GoUint32)SKY_base58_Hex2Base58String(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -13625,70 +13180,92 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_RandByte(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SKY_cipher_NewPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_base58_Hex2Base58Str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoSlice arg1 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewPubKey",&obj0,&obj1)) SWIG_fail; + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_base58_Hex2Base58Str",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewPubKey', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_base58_Hex2Base58Str', expecting string"); } (&arg1)->data = buffer; (&arg1)->len = size - 1; (&arg1)->cap = size; } + result = (GoUint32)SKY_base58_Hex2Base58Str(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - result = (GoUint32)SKY_cipher_NewPubKey(arg1,(unsigned char (*)[33])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_handle_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + Handle arg1 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_close",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + SKY_handle_close(arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromHex",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_PubKeyFromHex', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_copy",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cipher_PubKeyFromHex(arg1,(unsigned char (*)[33])arg2); + result = (GoUint32)SKY_handle_copy(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchInterruptPanic")) SWIG_fail; + result = (GoUint32)SKY_apputil_CatchInterruptPanic(); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -13696,32 +13273,61 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromHex(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchDebug")) SWIG_fail; + result = (GoUint32)SKY_apputil_CatchDebug(); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_apputil_PrintProgramStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_PrintProgramStatus")) SWIG_fail; + result = (GoUint32)SKY_apputil_PrintProgramStatus(); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Transaction__Handle arg1 ; + GoUint64 arg2 ; + GoUint32 arg3 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyFromSecKey",&obj0,&obj1)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; - } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFee",&obj0,&obj1,&obj2)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cipher_PubKeyFromSecKey((unsigned char (*)[32])arg1,(unsigned char (*)[33])arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "3"" of type '" "GoUint32""'"); + } + arg3 = (GoUint32)(val3); + result = (GoUint32)SKY_fee_VerifyTransactionFee(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -13729,42 +13335,39 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSecKey(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFeeForHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Sig *arg1 = (cipher__Sig *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - cipher__PubKey *arg3 = (cipher__PubKey *) 0 ; + GoUint64 arg1 ; + GoUint64 arg2 ; + GoUint32 arg3 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_PubKeyFromSig",&obj0,&obj1,&obj2)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg1 = &p->data; - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg3 = &p->data; - } - result = (GoUint32)SKY_cipher_PubKeyFromSig((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[33])arg3); + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFeeForHours",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "3"" of type '" "GoUint32""'"); + } + arg3 = (GoUint32)(val3); + result = (GoUint32)SKY_fee_VerifyTransactionFeeForHours(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -13772,56 +13375,79 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyFromSig(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + GoUint64 arg1 ; + GoUint32 arg2 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Verify",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + temp3 = 0; + arg3 = &temp3; } - result = (GoUint32)SKY_cipher_PubKey_Verify((unsigned char (*)[33])arg1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RequiredFee",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RequiredFee" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RequiredFee" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + result = (GoUint32)SKY_fee_RequiredFee(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_fee_RemainingHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoUint64 arg1 ; + GoUint32 arg2 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_PubKey_Hex",&obj0)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + temp3 = 0; + arg3 = &temp3; } - result = (GoUint32)SKY_cipher_PubKey_Hex((unsigned char (*)[33])arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RemainingHours",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RemainingHours" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RemainingHours" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + result = (GoUint32)SKY_fee_RemainingHours(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); } return resultobj; fail: @@ -13829,160 +13455,277 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_PubKey_Hex(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_PubKeyRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ; + Transaction__Handle arg1 ; + GoUint64 arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + GoUint64 *arg4 = (GoUint64 *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; + GoUint64 temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_PubKeyRipemd160",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); - cipher_Ripemd160* p = (cipher_Ripemd160*)argp; - arg2 = &p->data; + temp4 = 0; + arg4 = &temp4; } - result = (GoUint32)SKY_cipher_PubKeyRipemd160((unsigned char (*)[33])arg1,(unsigned char (*)[20])arg2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_TransactionFee",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_TransactionFee" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_fee_TransactionFee(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_NewSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_fee_TransactionFee__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_fee_TransactionFee__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_fee_TransactionFee'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin_UxOutArray *,GoUint64 *)\n" + " SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin__UxArray *,GoUint64 *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SKY_cli_GenerateAddressesInFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + GoString arg1 ; + GoUint64 arg2 ; + PasswordReader__Handle arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSecKey",&obj0,&obj1)) SWIG_fail; + { + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; + } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GenerateAddressesInFile",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSecKey', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateAddressesInFile', expecting string"); } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg2 = &p->data; + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PasswordReader__Handle, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_GenerateAddressesInFile" "', argument " "3"" of type '" "PasswordReader__Handle""'"); + } else { + arg3 = *((PasswordReader__Handle *)(argp3)); + } } - result = (GoUint32)SKY_cipher_NewSecKey(arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_cli_GenerateAddressesInFile(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + GoSlice arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromHex",&obj0,&obj1)) SWIG_fail; + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJSON",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromHex', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJSON', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } + result = (GoUint32)SKY_cli_FormatAddressesAsJSON(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg2 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - result = (GoUint32)SKY_cipher_SecKeyFromHex(arg1,(unsigned char (*)[32])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_FormatAddressesAsJoinedArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + GoSlice arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Verify",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - result = (GoUint32)SKY_cipher_SecKey_Verify((unsigned char (*)[32])arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_FormatAddressesAsJoinedArray",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_FormatAddressesAsJoinedArray', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; + } + result = (GoUint32)SKY_cli_FormatAddressesAsJoinedArray(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_AddressesToStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoSlice arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SecKey_Hex",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_AddressesToStrings",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_AddressesToStrings', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_cipher_SecKey_Hex((unsigned char (*)[32])arg1,arg2); + result = (GoUint32)SKY_cli_AddressesToStrings(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -13990,80 +13733,78 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SecKey_Hex(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_cipher_ECDH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_CheckWalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoSlice_ temp3 ; + WebRpcClient__Handle arg1 ; + GoString arg2 ; + BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_CheckWalletBalance",&obj0,&obj1,&obj2)) SWIG_fail; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_ECDH",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CheckWalletBalance', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg2 = &p->data; + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_CheckWalletBalance" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); } - result = (GoUint32)SKY_cipher_ECDH((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2,arg3); + arg3 = (BalanceResult_Handle *)(argp3); + result = (GoUint32)SKY_cli_CheckWalletBalance(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__Sig *arg2 = (cipher__Sig *) 0 ; + WebRpcClient__Handle arg1 ; + GoSlice arg2 ; + BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_NewSig",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetBalanceOfAddresses",&obj0,&obj1,&obj2)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_NewSig', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetBalanceOfAddresses', expecting string"); } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg2 = &p->data; + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetBalanceOfAddresses" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); } - result = (GoUint32)SKY_cipher_NewSig(arg1,(unsigned char (*)[65])arg2); + arg3 = (BalanceResult_Handle *)(argp3); + result = (GoUint32)SKY_cli_GetBalanceOfAddresses(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14071,68 +13812,132 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_NewSig(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_SKY_cipher_SigFromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoString arg1 ; - cipher__Sig *arg2 = (cipher__Sig *) 0 ; + GoString arg2 ; + GoSlice arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + coin__UxArray *arg5 = (coin__UxArray *) 0 ; + GoSlice_ temp4 ; + GoSlice_ temp5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SigFromHex",&obj0,&obj1)) SWIG_fail; + { + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; + } + { + temp5.data = NULL; + temp5.len = 0; + temp5.cap = 0; + arg5 = (coin__UxArray *)&temp5; + } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_certutil_NewTLSCertPair",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SigFromHex', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); } (&arg1)->p = buffer; (&arg1)->n = size - 1; } { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg2 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - result = (GoUint32)SKY_cipher_SigFromHex(arg1,(unsigned char (*)[65])arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); + } + (&arg3)->data = buffer; + (&arg3)->len = size - 1; + (&arg3)->cap = size; + } + result = (GoUint32)SKY_certutil_NewTLSCertPair(arg1,arg2,arg3,arg4,arg5); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len )); + free( (void*)arg5->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_Sig_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - cipher__Sig *arg1 = (cipher__Sig *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; +SWIGINTERN PyObject *_wrap_SKY_coin_NewBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Block__Handle arg1 ; + GoUint64 arg2 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + Transactions__Handle arg4 ; + FeeCalculator *arg5 = (FeeCalculator *) 0 ; + Block__Handle *arg6 = (Block__Handle *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + FeeCalculator temp5 ; + Handle temp6 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg6 = &temp6; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Sig_Hex",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_coin_NewBlock",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewBlock" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); { void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg1 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } - result = (GoUint32)SKY_cipher_Sig_Hex((unsigned char (*)[65])arg1,arg2); + { + SWIG_AsVal_long(obj3, (long*)&arg4); + } + { + if (!PyCallable_Check(obj4)) SWIG_fail; + temp5.callback = _WrapperFeeCalculator; + temp5.context = obj4; + arg5 = &temp5; + } + result = (GoUint32)SKY_coin_NewBlock(arg1,arg2,(unsigned char (*)[32])arg3,arg4,arg5,arg6); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); } return resultobj; fail: @@ -14140,42 +13945,31 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Sig_Hex(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SKY_cipher_SignHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_SignedBlock_VerifySignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; - cipher__Sig *arg3 = (cipher__Sig *) 0 ; + coin__SignedBlock *arg1 = (coin__SignedBlock *) 0 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SignHash",&obj0,&obj1,&obj2)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg1 = &p->data; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SignedBlock_VerifySignature",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__SignedBlock, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SignedBlock_VerifySignature" "', argument " "1"" of type '" "coin__SignedBlock *""'"); } + arg1 = (coin__SignedBlock *)(argp1); { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; arg2 = &p->data; } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg3 = &p->data; - } - result = (GoUint32)SKY_cipher_SignHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[65])arg3); + result = (GoUint32)SKY_coin_SignedBlock_VerifySignature(arg1,(unsigned char (*)[33])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14183,64 +13977,65 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SignHash(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyAddressSignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_NewGenesisBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; cipher__Address *arg1 = (cipher__Address *) 0 ; - cipher__Sig *arg2 = (cipher__Sig *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + GoUint64 arg2 ; + GoUint64 arg3 ; + Block__Handle *arg4 = (Block__Handle *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + Handle temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyAddressSignedHash",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg4 = &temp4; + } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewGenesisBlock",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_VerifyAddressSignedHash" "', argument " "1"" of type '" "cipher__Address *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "1"" of type '" "cipher__Address *""'"); } arg1 = (cipher__Address *)(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewGenesisBlock" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + result = (GoUint32)SKY_coin_NewGenesisBlock(arg1,arg2,arg3,arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg2 = &p->data; - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); } - result = (GoUint32)SKY_cipher_VerifyAddressSignedHash(arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Sig *arg1 = (cipher__Sig *) 0 ; + Block__Handle arg1 ; cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_VerifySignedHash",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashHeader",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg1 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } { void *argp = 0; @@ -14250,7 +14045,7 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM( cipher_SHA256* p = (cipher_SHA256*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_cipher_VerifySignedHash((unsigned char (*)[65])arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_coin_Block_HashHeader(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14258,42 +14053,27 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_VerifySignedHash(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyPubKeySignedHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_PreHashHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__Sig *arg2 = (cipher__Sig *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; + Block__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_VerifyPubKeySignedHash",&obj0,&obj1,&obj2)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; - } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_PreHashHeader",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } { void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + arg2 = &p->data; } - result = (GoUint32)SKY_cipher_VerifyPubKeySignedHash((unsigned char (*)[33])arg1,(unsigned char (*)[65])arg2,(unsigned char (*)[32])arg3); + result = (GoUint32)SKY_coin_Block_PreHashHeader(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14301,183 +14081,109 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_VerifyPubKeySignedHash(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + Block__Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateKeyPair",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + temp2 = 0; + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Time",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cipher_GenerateKeyPair((unsigned char (*)[33])arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_coin_Block_Time(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_Seq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; - cipher__SecKey *arg3 = (cipher__SecKey *) 0 ; + Block__Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_GenerateDeterministicKeyPair",&obj0,&obj1,&obj2)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPair', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + temp2 = 0; + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Seq",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } + result = (GoUint32)SKY_coin_Block_Seq(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg3 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } - result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPair(arg1,(unsigned char (*)[33])arg2,(unsigned char (*)[32])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_DeterministicKeyPairIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_HashBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - cipher__PubKey *arg3 = (cipher__PubKey *) 0 ; - cipher__SecKey *arg4 = (cipher__SecKey *) 0 ; - GoSlice_ temp2 ; + Block__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_HashBody",&obj0,&obj1)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_DeterministicKeyPairIterator",&obj0,&obj1,&obj2)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DeterministicKeyPairIterator', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg3 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } { void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg4 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_cipher_DeterministicKeyPairIterator(arg1,arg2,(unsigned char (*)[33])arg3,(unsigned char (*)[32])arg4); + result = (GoUint32)SKY_coin_Block_HashBody(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoInt arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - long long val2 ; - int ecode2 = 0 ; - GoSlice_ temp3 ; + Block__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_Size",&obj0)) SWIG_fail; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairs",&obj0,&obj1)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairs', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairs" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairs(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_Block_Size(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -14485,116 +14191,74 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(PyOb } -SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - Py_ssize_t ii; +SWIGINTERN PyObject *_wrap_SKY_coin_Block_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Block__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; - if (!PyTuple_Check(args)) SWIG_fail; - argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { - argv[ii] = PyTuple_GET_ITEM(args,ii); + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (argc == 2) { - int _v; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 ); - _v = SWIG_IsOK(res) ? 1 : 0; - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_0(self, args); - } - } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Block_String",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (argc == 2) { - int _v; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( argv[0], &buffer, &size, 0 ); - _v = SWIG_IsOK(res) ? 1 : 0; - } - if (_v) { - { - int res = SWIG_AsVal_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SKY_cipher_GenerateDeterministicKeyPairs__SWIG_1(self, args); - } - } + result = (GoUint32)SKY_coin_Block_String(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - + return resultobj; fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_cipher_GenerateDeterministicKeyPairs'.\n" - " Possible C/C++ prototypes are:\n" - " wrap_SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,cipher_SecKeys *)\n" - " SKY_cipher_GenerateDeterministicKeyPairs(GoSlice,GoInt,coin__UxArray *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Block_GetTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoInt arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - long long val2 ; - int ecode2 = 0 ; - GoSlice_ temp3 ; - GoSlice_ temp4 ; + Block__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + Transaction__Handle *arg3 = (Transaction__Handle *) 0 ; + GoUint8 *arg4 = (GoUint8 *) 0 ; + Handle temp3 ; + GoUint8 temp4 ; + int res4 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + arg3 = &temp3; } + arg4 = &temp4; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Block_GetTransaction",&obj0,&obj1)) SWIG_fail; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_GenerateDeterministicKeyPairsSeed",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_GenerateDeterministicKeyPairsSeed', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_cipher_GenerateDeterministicKeyPairsSeed" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_cipher_GenerateDeterministicKeyPairsSeed(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_coin_Block_GetTransaction(arg1,(unsigned char (*)[32])arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + if (SWIG_IsTmpObj(res4)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); + } else { + int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -14602,22 +14266,63 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed(PyObject } -SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_NewBlockHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + GoUint64 arg3 ; + GoUint64 arg4 ; + BlockBody__Handle arg5 ; + coin__BlockHeader *arg6 = (coin__BlockHeader *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + unsigned long long val4 ; + int ecode4 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_CheckSecKey",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_coin_NewBlockHeader",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_NewBlockHeader" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + } + arg1 = (coin__BlockHeader *)(argp1); { void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_cipher_CheckSecKey((unsigned char (*)[32])arg1); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_NewBlockHeader" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_NewBlockHeader" "', argument " "4"" of type '" "GoUint64""'"); + } + arg4 = (GoUint64)(val4); + { + SWIG_AsVal_long(obj4, (long*)&arg5); + } + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_coin_NewBlockHeader" "', argument " "6"" of type '" "coin__BlockHeader *""'"); + } + arg6 = (coin__BlockHeader *)(argp6); + result = (GoUint32)SKY_coin_NewBlockHeader(arg1,(unsigned char (*)[32])arg2,arg3,arg4,arg5,arg6); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14625,23 +14330,22 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKey(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_CheckSecKeyHash",&obj0,&obj1)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockHeader_Hash",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Hash" "', argument " "1"" of type '" "coin__BlockHeader *""'"); } + arg1 = (coin__BlockHeader *)(argp1); { void *argp = 0; int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); @@ -14650,7 +14354,7 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(s cipher_SHA256* p = (cipher_SHA256*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_cipher_CheckSecKeyHash((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2); + result = (GoUint32)SKY_coin_BlockHeader_Hash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14658,33 +14362,33 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_CheckSecKeyHash(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_FromString",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_droplet_FromString', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_Bytes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_Bytes" "', argument " "1"" of type '" "coin__BlockHeader *""'"); } - result = (GoUint32)SKY_droplet_FromString(arg1,arg2); + arg1 = (coin__BlockHeader *)(argp1); + result = (GoUint32)SKY_coin_BlockHeader_Bytes(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -14692,12 +14396,12 @@ SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockHeader_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; GoString_ *arg2 = (GoString_ *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -14707,13 +14411,13 @@ SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_ToString",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_droplet_ToString" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - result = (GoUint32)SKY_droplet_ToString(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockHeader_String",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_BlockHeader_String" "', argument " "1"" of type '" "coin__BlockHeader *""'"); + } + arg1 = (coin__BlockHeader *)(argp1); + result = (GoUint32)SKY_coin_BlockHeader_String(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); @@ -14725,118 +14429,27 @@ SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_handle_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Handle arg1 ; - PyObject * obj0 = 0 ; - - if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_close",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - SKY_handle_close(arg1); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_handle_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + BlockBody__Handle arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_handle_copy",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_BlockBody_Hash",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_handle_copy(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoUint64 arg2 ; - GoUint32 arg3 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFee",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFee" "', argument " "3"" of type '" "GoUint32""'"); - } - arg3 = (GoUint32)(val3); - result = (GoUint32)SKY_fee_VerifyTransactionFee(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFeeForHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint64 arg2 ; - GoUint32 arg3 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned int val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_fee_VerifyTransactionFeeForHours",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_fee_VerifyTransactionFeeForHours" "', argument " "3"" of type '" "GoUint32""'"); - } - arg3 = (GoUint32)(val3); - result = (GoUint32)SKY_fee_VerifyTransactionFeeForHours(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_BlockBody_Hash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -14844,39 +14457,30 @@ SWIGINTERN PyObject *_wrap_SKY_fee_VerifyTransactionFeeForHours(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint32 arg2 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - GoUint64 temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - { - temp3 = 0; - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RequiredFee",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RequiredFee" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RequiredFee" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - result = (GoUint32)SKY_fee_RequiredFee(arg1,arg2,arg3); + BlockBody__Handle *arg1 = (BlockBody__Handle *) 0 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + Handle temp1 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; + GoUint32 result; + + { + arg1 = &temp1; + } + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_BlockBody_Size")) SWIG_fail; + result = (GoUint32)SKY_coin_BlockBody_Size(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + } + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -14884,39 +14488,29 @@ SWIGINTERN PyObject *_wrap_SKY_fee_RequiredFee(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SKY_fee_RemainingHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_BlockBody_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint32 arg2 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - GoUint64 temp3 ; + BlockBody__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3 = 0; - arg3 = &temp3; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_RemainingHours",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_fee_RemainingHours" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_RemainingHours" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - result = (GoUint32)SKY_fee_RemainingHours(arg1,arg2,arg3); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_BlockBody_Bytes",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_coin_BlockBody_Bytes(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -14924,16 +14518,14 @@ SWIGINTERN PyObject *_wrap_SKY_fee_RemainingHours(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoUint64 arg2 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + Transaction__Handle arg2 ; coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoUint64 *arg4 = (GoUint64 *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; GoSlice_ temp3 ; - GoUint64 temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; @@ -14944,237 +14536,142 @@ SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee__SWIG_1(PyObject *SWIGUNUSEDPA temp3.cap = 0; arg3 = (coin__UxArray *)&temp3; } - { - temp4 = 0; - arg4 = &temp4; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_CreateUnspents",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspents" "', argument " "1"" of type '" "coin__BlockHeader *""'"); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_fee_TransactionFee",&obj0,&obj1)) SWIG_fail; + arg1 = (coin__BlockHeader *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + SWIG_AsVal_long(obj1, (long*)&arg2); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_fee_TransactionFee" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_fee_TransactionFee(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_coin_CreateUnspents(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); free( (void*)arg3->data ); } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 )); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_fee_TransactionFee(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspents(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 3) && (ii < argc); ii++) { + for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); + _v = PyInt_Check(argv[1]) ? 1 : 0; } if (_v) { - return _wrap_SKY_fee_TransactionFee__SWIG_1(self, args); + return _wrap_SKY_coin_CreateUnspents__SWIG_0(self, args); } } } - if (argc == 3) { + if (argc == 2) { int _v; - { - _v = PyInt_Check(argv[0]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_coin__BlockHeader, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); - _v = SWIG_CheckState(res); + _v = PyInt_Check(argv[1]) ? 1 : 0; } if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_fee_TransactionFee__SWIG_0(self, args); - } + return _wrap_SKY_coin_CreateUnspents__SWIG_1(self, args); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_fee_TransactionFee'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_CreateUnspents'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin_UxOutArray *,GoUint64 *)\n" - " SKY_fee_TransactionFee(Transaction__Handle,GoUint64,coin__UxArray *,GoUint64 *)\n"); + " wrap_SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin_UxOutArray *)\n" + " SKY_coin_CreateUnspents(coin__BlockHeader *,Transaction__Handle,coin__UxArray *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ; - GoSlice arg2 ; - GoSlice arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoSlice_ temp4 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; - - { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Encrypt",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Encrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); - } - arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1); - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Encrypt', expecting string"); - } - (&arg3)->data = buffer; - (&arg3)->len = size - 1; - (&arg3)->cap = size; - } - result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Encrypt(arg1,arg2,arg3,arg4); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_CreateUnspent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - encrypt__ScryptChacha20poly1305 *arg1 = (encrypt__ScryptChacha20poly1305 *) 0 ; - GoSlice arg2 ; - GoSlice arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; + coin__BlockHeader *arg1 = (coin__BlockHeader *) 0 ; + Transaction__Handle arg2 ; + GoInt arg3 ; + coin__UxOut *arg4 = (coin__UxOut *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - GoSlice_ temp4 ; + long long val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; GoUint32 result; - { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_encrypt_ScryptChacha20poly1305_Decrypt",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_encrypt__ScryptChacha20poly1305, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_CreateUnspent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__BlockHeader, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_encrypt_ScryptChacha20poly1305_Decrypt" "', argument " "1"" of type '" "encrypt__ScryptChacha20poly1305 *""'"); - } - arg1 = (encrypt__ScryptChacha20poly1305 *)(argp1); - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_CreateUnspent" "', argument " "1"" of type '" "coin__BlockHeader *""'"); } + arg1 = (coin__BlockHeader *)(argp1); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_encrypt_ScryptChacha20poly1305_Decrypt', expecting string"); - } - (&arg3)->data = buffer; - (&arg3)->len = size - 1; - (&arg3)->cap = size; + SWIG_AsVal_long(obj1, (long*)&arg2); } - result = (GoUint32)SKY_encrypt_ScryptChacha20poly1305_Decrypt(arg1,arg2,arg3,arg4); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_CreateUnspent" "', argument " "3"" of type '" "GoInt""'"); + } + arg3 = (GoInt)(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SKY_coin_CreateUnspent" "', argument " "4"" of type '" "coin__UxOut *""'"); } + arg4 = (coin__UxOut *)(argp4); + result = (GoUint32)SKY_coin_CreateUnspent(arg1,arg2,arg3,arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - Client__Handle *arg2 = (Client__Handle *) 0 ; - Handle temp2 ; + Block__Handle arg1 ; + coin__Block **arg2 = (coin__Block **) 0 ; + coin__Block *temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { + temp2 = NULL; arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewClient",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockObject",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewClient', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_NewClient(arg1,arg2); + result = (GoUint32)SKY_coin_GetBlockObject(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Block, 0 )); } return resultobj; fail: @@ -15182,28 +14679,25 @@ SWIGINTERN PyObject *_wrap_SKY_api_NewClient(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_GetBlockBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Block__Handle arg1 ; + BlockBody__Handle *arg2 = (BlockBody__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CSRF",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetBlockBody",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Client_CSRF(arg1,arg2); + result = (GoUint32)SKY_coin_GetBlockBody(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -15211,10 +14705,10 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_NewEmptyBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; + Transactions__Handle arg1 ; + Block__Handle *arg2 = (Block__Handle *) 0 ; Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -15222,11 +14716,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self) { arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Version",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_NewEmptyBlock",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Client_Version(arg1,arg2); + result = (GoUint32)SKY_coin_NewEmptyBlock(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); @@ -15237,25 +14731,65 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + GoInterface arg1 ; + void *argp1 ; + int res1 = 0 ; PyObject * obj0 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewError",&obj0)) SWIG_fail; { - arg2 = &temp2; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_GoInterface, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); + } else { + arg1 = *((GoInterface *)(argp1)); + } } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Outputs",&obj0)) SWIG_fail; + result = (GoUint32)SKY_wallet_NewError(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; + Options__Handle arg2 ; + Wallet__Handle *arg3 = (Wallet__Handle *) 0 ; + Handle temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg3 = &temp3; } - result = (GoUint32)SKY_api_Client_Outputs(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewWallet",&obj0,&obj1)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewWallet', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; + } + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } + result = (GoUint32)SKY_wallet_NewWallet(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -15263,20 +14797,17 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + Wallet__Handle arg1 ; GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoString arg3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForAddresses",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_Lock",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -15285,28 +14816,35 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUS size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForAddresses', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string"); } (&arg2)->data = buffer; (&arg2)->len = size - 1; (&arg2)->cap = size; } - result = (GoUint32)SKY_api_Client_OutputsForAddresses(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; } + result = (GoUint32)SKY_wallet_Wallet_Lock(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + Wallet__Handle arg1 ; GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; + Wallet__Handle *arg3 = (Wallet__Handle *) 0 ; Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; @@ -15315,7 +14853,7 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDP { arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForHashes",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Unlock",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -15324,13 +14862,13 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDP size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForHashes', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Unlock', expecting string"); } (&arg2)->data = buffer; (&arg2)->len = size - 1; (&arg2)->cap = size; } - result = (GoUint32)SKY_api_Client_OutputsForHashes(arg1,arg2,arg3); + result = (GoUint32)SKY_wallet_Wallet_Unlock(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); @@ -15341,10 +14879,10 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; + GoString arg1 ; + Wallet__Handle *arg2 = (Wallet__Handle *) 0 ; Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -15352,11 +14890,18 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(se { arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CoinSupply",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Load",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Load', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_api_Client_CoinSupply(arg1,arg2); + result = (GoUint32)SKY_wallet_Load(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); @@ -15367,20 +14912,15 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + Wallet__Handle arg1 ; GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockByHash",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Save",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -15389,15 +14929,88 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(s size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_BlockByHash', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Save', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; } - result = (GoUint32)SKY_api_Client_BlockByHash(arg1,arg2,arg3); + result = (GoUint32)SKY_wallet_Wallet_Save(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Wallet__Handle arg1 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Validate",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_wallet_Wallet_Validate(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Type",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_wallet_Wallet_Type(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Version",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_wallet_Wallet_Version(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -15405,34 +15018,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoUint64 arg2 ; - Handle *arg3 = (Handle *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockBySeq",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Filename",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_BlockBySeq" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_api_Client_BlockBySeq(arg1,arg2,arg3); + result = (GoUint32)SKY_wallet_Wallet_Filename(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -15440,38 +15047,28 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Blocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Blocks",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Label",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Blocks', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; - } - result = (GoUint32)SKY_api_Client_Blocks(arg1,arg2,arg3); + result = (GoUint32)SKY_wallet_Wallet_Label(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -15479,34 +15076,27 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Blocks(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_IsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoUint64 arg2 ; - Handle *arg3 = (Handle *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_LastBlocks",&obj0,&obj1)) SWIG_fail; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_IsEncrypted",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_LastBlocks" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_api_Client_LastBlocks(arg1,arg2,arg3); + result = (GoUint32)SKY_wallet_Wallet_IsEncrypted(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -15514,25 +15104,38 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + Wallet__Handle arg1 ; + GoUint64 arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainMetadata",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_GenerateAddresses",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Client_BlockchainMetadata(arg1,arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_Wallet_GenerateAddresses" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_wallet_Wallet_GenerateAddresses(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -15540,25 +15143,29 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + Wallet__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainProgress",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_GetAddresses",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Client_BlockchainProgress(arg1,arg2); + result = (GoUint32)SKY_wallet_Wallet_GetAddresses(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -15566,115 +15173,142 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Balance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoSlice arg2 ; - wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ; + Wallet__Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + wallet__Entry *arg3 = (wallet__Entry *) 0 ; + GoUint8 *arg4 = (GoUint8 *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + GoUint8 temp4 ; + int res4 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_Balance",&obj0,&obj1,&obj2)) SWIG_fail; + arg4 = &temp4; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_GetEntry",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Balance', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "2"" of type '" "cipher__Address *""'"); } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 | 0 ); + arg2 = (cipher__Address *)(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Entry, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_Balance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "3"" of type '" "wallet__Entry *""'"); } - arg3 = (wallet__BalancePair *)(argp3); - result = (GoUint32)SKY_api_Client_Balance(arg1,arg2,arg3); + arg3 = (wallet__Entry *)(argp3); + result = (GoUint32)SKY_wallet_Wallet_GetEntry(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res4)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); + } else { + int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_AddEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + wallet__Entry *arg2 = (wallet__Entry *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UxOut",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_AddEntry",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UxOut', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_AddEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); } - result = (GoUint32)SKY_api_Client_UxOut(arg1,arg2,arg3); + arg2 = (wallet__Entry *)(argp2); + result = (GoUint32)SKY_wallet_Wallet_AddEntry(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoUint64 arg1 ; + GoUint64 arg2 ; + GoUint8 arg3 ; + GoUint64 *arg4 = (GoUint64 *) 0 ; + coin__UxArray *arg5 = (coin__UxArray *) 0 ; + GoUint64 *arg6 = (GoUint64 *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned char val3 ; + int ecode3 = 0 ; + GoUint64 temp4 ; + GoSlice_ temp5 ; + GoUint64 temp6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp4 = 0; + arg4 = &temp4; + } + { + temp5.data = NULL; + temp5.len = 0; + temp5.cap = 0; + arg5 = (coin__UxArray *)&temp5; + } + { + temp6 = 0; + arg6 = &temp6; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressUxOuts",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_DistributeSpendHours",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "3"" of type '" "GoUint8""'"); + } + arg3 = (GoUint8)(val3); + result = (GoUint32)SKY_wallet_DistributeSpendHours(arg1,arg2,arg3,arg4,arg5,arg6); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - SWIG_AsVal_long(obj0, (long*)&arg1); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 )); } { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressUxOuts', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len )); + free( (void*)arg5->data ); } - result = (GoUint32)SKY_api_Client_AddressUxOuts(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg6 )); } return resultobj; fail: @@ -15682,37 +15316,46 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeCoinHoursProportional(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ; - Handle temp3 ; + GoSlice arg1 ; + GoUint64 arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Wallet",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_DistributeCoinHoursProportional",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Wallet', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_DistributeCoinHoursProportional', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_api_Client_Wallet(arg1,arg2,arg3); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeCoinHoursProportional" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_wallet_DistributeCoinHoursProportional(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -15720,25 +15363,45 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Wallets__Handle *arg2 = (Wallets__Handle *) 0 ; - Handle temp2 ; + GoUint64 arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + GoSlice_ temp2 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Wallets",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - result = (GoUint32)SKY_api_Client_Wallets(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewUxBalances",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalances" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + result = (GoUint32)SKY_wallet_NewUxBalances(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -15746,129 +15409,95 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateUnencryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoInt arg4 ; - WalletResponse__Handle *arg5 = (WalletResponse__Handle *) 0 ; - long long val4 ; - int ecode4 = 0 ; - Handle temp5 ; + GoUint64 arg1 ; + coin__UxOut *arg2 = (coin__UxOut *) 0 ; + wallet__UxBalance *arg3 = (wallet__UxBalance *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; GoUint32 result; - { - arg5 = &temp5; - } - if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_CreateUnencryptedWallet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewUxBalance",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalance" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewUxBalance" "', argument " "2"" of type '" "coin__UxOut *""'"); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + arg2 = (coin__UxOut *)(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__UxBalance, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewUxBalance" "', argument " "3"" of type '" "wallet__UxBalance *""'"); } - ecode4 = SWIG_AsVal_long_SS_long(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_CreateUnencryptedWallet" "', argument " "4"" of type '" "GoInt""'"); - } - arg4 = (GoInt)(val4); - result = (GoUint32)SKY_api_Client_CreateUnencryptedWallet(arg1,arg2,arg3,arg4,arg5); + arg3 = (wallet__UxBalance *)(argp3); + result = (GoUint32)SKY_wallet_NewUxBalance(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoString arg4 ; - GoInt arg5 ; - WalletResponse__Handle *arg6 = (WalletResponse__Handle *) 0 ; - long long val5 ; - int ecode5 = 0 ; - Handle temp6 ; + GoSlice arg1 ; + GoUint64 arg2 ; + GoUint64 arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; GoUint32 result; { - arg6 = &temp6; - } - if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_api_Client_CreateEncryptedWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMinimizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMinimizeUxOuts', expecting string"); } - (&arg4)->p = buffer; - (&arg4)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SKY_api_Client_CreateEncryptedWallet" "', argument " "5"" of type '" "GoInt""'"); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "2"" of type '" "GoUint64""'"); } - arg5 = (GoInt)(val5); - result = (GoUint32)SKY_api_Client_CreateEncryptedWallet(arg1,arg2,arg3,arg4,arg5,arg6); + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + result = (GoUint32)SKY_wallet_ChooseSpendsMinimizeUxOuts(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -15876,58 +15505,55 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NewWalletAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoInt arg3 ; - GoString arg4 ; - Strings__Handle *arg5 = (Strings__Handle *) 0 ; - long long val3 ; + GoSlice arg1 ; + GoUint64 arg2 ; + GoUint64 arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned long long val3 ; int ecode3 = 0 ; - Handle temp5 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; GoUint32 result; { - arg5 = &temp5; - } - if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_NewWalletAddress",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; } + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMaximizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMaximizeUxOuts', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_api_Client_NewWalletAddress" "', argument " "3"" of type '" "GoInt""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "3"" of type '" "GoUint64""'"); } - arg3 = (GoInt)(val3); - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string"); - } - (&arg4)->p = buffer; - (&arg4)->n = size - 1; - } - result = (GoUint32)SKY_api_Client_NewWalletAddress(arg1,arg2,arg3,arg4,arg5); + arg3 = (GoUint64)(val3); + result = (GoUint32)SKY_wallet_ChooseSpendsMaximizeUxOuts(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -15935,11 +15561,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NewWalletAddress(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + WebRpcClient__Handle arg1 ; GoString arg2 ; - wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ; + ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject * obj0 = 0 ; @@ -15947,7 +15573,7 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletBalance",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetWalletOutputsFromFile",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -15956,17 +15582,17 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletBalance', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetWalletOutputsFromFile', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_WalletBalance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputsFromFile" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); } - arg3 = (wallet__BalancePair *)(argp3); - result = (GoUint32)SKY_api_Client_WalletBalance(arg1,arg2,arg3); + arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3); + result = (GoUint32)SKY_cli_GetWalletOutputsFromFile(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -15974,71 +15600,167 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Spend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoUint64 arg4 ; - GoString arg5 ; - SpendResult_Handle *arg6 = (SpendResult_Handle *) 0 ; - unsigned long long val4 ; - int ecode4 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + WebRpcClient__Handle arg1 ; + Wallet__Handle *arg2 = (Wallet__Handle *) 0 ; + ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ; + Handle temp2 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_api_Client_Spend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + { + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GetWalletOutputs",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } + res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputs" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); + } + arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3); + result = (GoUint32)SKY_cli_GetWalletOutputs(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58Address",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58Address', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; + } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58Address" "', argument " "2"" of type '" "cipher__Address *""'"); } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_cipher_DecodeBase58Address(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoSlice arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromBytes",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_AddressFromBytes', expecting string"); } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_Spend" "', argument " "4"" of type '" "GoUint64""'"); - } - arg4 = (GoUint64)(val4); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromBytes" "', argument " "2"" of type '" "cipher__Address *""'"); + } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_cipher_AddressFromBytes(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromPubKey",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); - } - (&arg5)->p = buffer; - (&arg5)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg1 = &p->data; + } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromPubKey" "', argument " "2"" of type '" "cipher__Address *""'"); + } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_cipher_AddressFromPubKey((unsigned char (*)[33])arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromSecKey",&obj0,&obj1)) SWIG_fail; + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); + cipher_SecKey* p = (cipher_SecKey*)argp; + arg1 = &p->data; } - res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_SpendResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_api_Client_Spend" "', argument " "6"" of type '" "SpendResult_Handle *""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromSecKey" "', argument " "2"" of type '" "cipher__Address *""'"); } - arg6 = (SpendResult_Handle *)(argp6); - result = (GoUint32)SKY_api_Client_Spend(arg1,arg2,arg3,arg4,arg5,arg6); + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_cipher_AddressFromSecKey((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -16046,33 +15768,65 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Spend(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ; - Handle temp2 ; - Handle temp3 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; GoUint32 result; - { - arg2 = &temp2; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Null",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Null" "', argument " "1"" of type '" "cipher__Address *""'"); } - { - arg3 = &temp3; + arg1 = (cipher__Address *)(argp1); + result = (GoUint32)SKY_cipher_Address_Null(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CreateTransaction",&obj0)) SWIG_fail; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + cipher__Address *arg1 = (cipher__Address *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoSlice_ temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - result = (GoUint32)SKY_api_Client_CreateTransaction(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Bytes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Bytes" "', argument " "1"" of type '" "cipher__Address *""'"); } + arg1 = (cipher__Address *)(argp1); + result = (GoUint32)SKY_cipher_Address_Bytes(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -16080,41 +15834,31 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_UpdateWallet",&obj0,&obj1,&obj2)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Verify",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Verify" "', argument " "1"" of type '" "cipher__Address *""'"); } + arg1 = (cipher__Address *)(argp1); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_Client_UpdateWallet(arg1,arg2,arg3); + result = (GoUint32)SKY_cipher_Address_Verify(arg1,(unsigned char (*)[33])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -16122,25 +15866,32 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_WalletFolderName",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_String",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_String" "', argument " "1"" of type '" "cipher__Address *""'"); } - result = (GoUint32)SKY_api_Client_WalletFolderName(arg1,arg2); + arg1 = (cipher__Address *)(argp1); + result = (GoUint32)SKY_cipher_Address_String(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -16148,90 +15899,71 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NewSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoInt arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - long long val2 ; - int ecode2 = 0 ; - GoString temp3 ; + cipher__Address *arg1 = (cipher__Address *) 0 ; + cipher__Checksum *arg2 = (cipher__Checksum *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Checksum",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Checksum" "', argument " "1"" of type '" "cipher__Address *""'"); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NewSeed",&obj0,&obj1)) SWIG_fail; + arg1 = (cipher__Address *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum"); + cipher_Checksum* p = (cipher_Checksum*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_NewSeed" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_api_Client_NewSeed(arg1,arg2,arg3); + result = (GoUint32)SKY_cipher_Address_Checksum(arg1,(unsigned char (*)[4])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddUint64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoString_ *arg4 = (GoString_ *) 0 ; - GoString temp4 ; + GoUint64 arg1 ; + GoUint64 arg2 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - temp4.p = NULL; - temp4.n = 0; - arg4 = (GoString_ *)&temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletSeed",&obj0,&obj1,&obj2)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + temp3 = 0; + arg3 = &temp3; } - result = (GoUint32)SKY_api_Client_WalletSeed(arg1,arg2,arg3,arg4); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddUint64",&obj0,&obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_AddUint64" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_AddUint64" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_coin_AddUint64(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); - free( (void*)arg4->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); } return resultobj; fail: @@ -16239,37 +15971,30 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletSeed(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Uint64ToInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoUint64 arg1 ; + GoInt64 *arg2 = (GoInt64 *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + GoInt64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnection",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NetworkConnection', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + temp2 = 0; + arg2 = &temp2; } - result = (GoUint32)SKY_api_Client_NetworkConnection(arg1,arg2,arg3); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Uint64ToInt64",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_Uint64ToInt64" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + result = (GoUint32)SKY_coin_Uint64ToInt64(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -16277,34 +16002,62 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_Int64ToUint64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - api__NetworkConnectionsFilter *arg2 = (api__NetworkConnectionsFilter *) 0 ; - Handle *arg3 = (Handle *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - Handle temp3 ; + GoInt64 arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + long long val1 ; + int ecode1 = 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp2 = 0; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnections",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Int64ToUint64",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_Int64ToUint64" "', argument " "1"" of type '" "GoInt64""'"); + } + arg1 = (GoInt64)(val1); + result = (GoUint32)SKY_coin_Int64ToUint64(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_NetworkConnections" "', argument " "2"" of type '" "api__NetworkConnectionsFilter *""'"); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } - arg2 = (api__NetworkConnectionsFilter *)(argp2); - result = (GoUint32)SKY_api_Client_NetworkConnections(arg1,arg2,arg3); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_IntToUint32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoInt arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + long long val1 ; + int ecode1 = 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + GoUint32 result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_IntToUint32",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_IntToUint32" "', argument " "1"" of type '" "GoInt""'"); + } + arg1 = (GoInt)(val1); + result = (GoUint32)SKY_coin_IntToUint32(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -16312,29 +16065,43 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnections(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkDefaultPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; + GoString arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + Handle temp1 ; + GoString temp3 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + arg1 = &temp1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkDefaultPeers",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - result = (GoUint32)SKY_api_Client_NetworkDefaultPeers(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_Get",&obj0)) SWIG_fail; + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_Get', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + result = (GoUint32)SKY_map_Get(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -16342,29 +16109,32 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkDefaultPeers(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; + GoString arg2 ; + Handle temp1 ; PyObject * obj0 = 0 ; - GoUint32 result; + GoUint8 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + arg1 = &temp1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkTrustedPeers",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_HasKey",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_HasKey', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - result = (GoUint32)SKY_api_Client_NetworkTrustedPeers(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + result = (GoUint8)SKY_map_HasKey(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); } return resultobj; fail: @@ -16372,29 +16142,20 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkExchangedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_map_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; - PyObject * obj0 = 0 ; + GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; + Handle temp1 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkExchangedPeers",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg1 = &temp1; } - result = (GoUint32)SKY_api_Client_NetworkExchangedPeers(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)":SKY_map_Close")) SWIG_fail; + result = (GoUint32)SKY_map_Close(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); } return resultobj; fail: @@ -16402,25 +16163,77 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkExchangedPeers(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_api_Client_PendingTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + WebRpcClient__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; + GoSlice arg4 ; + PasswordReader__Handle arg5 ; + Transaction__Handle *arg6 = (Transaction__Handle *) 0 ; + void *argp5 ; + int res5 = 0 ; + Handle temp6 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; GoUint32 result; { - arg2 = &temp2; + arg6 = &temp6; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_PendingTransactions",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_cli_CreateRawTxFromWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Client_PendingTransactions(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); + } + (&arg4)->data = buffer; + (&arg4)->len = size - 1; + (&arg4)->cap = size; + } + { + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_PasswordReader__Handle, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); + } else { + arg5 = *((PasswordReader__Handle *)(argp5)); + } + } + result = (GoUint32)SKY_cli_CreateRawTxFromWallet(arg1,arg2,arg3,arg4,arg5,arg6); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); } return resultobj; fail: @@ -16428,20 +16241,30 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_PendingTransactions(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + WebRpcClient__Handle arg1 ; GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoString arg3 ; + GoString arg4 ; + GoSlice arg5 ; + PasswordReader__Handle arg6 ; + Transaction__Handle *arg7 = (Transaction__Handle *) 0 ; + void *argp6 ; + int res6 = 0 ; + Handle temp7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; GoUint32 result; { - arg3 = &temp3; + arg7 = &temp7; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transaction",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTxFromAddress",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -16450,54 +16273,57 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Transaction(PyObject *SWIGUNUSEDPARM(s size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transaction', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; } - result = (GoUint32)SKY_api_Client_Transaction(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_api_Client_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Client__Handle arg1 ; - GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - { - arg3 = &temp3; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transactions",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); + } + (&arg4)->p = buffer; + (&arg4)->n = size - 1; } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transactions', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + (&arg5)->data = buffer; + (&arg5)->len = size - 1; + (&arg5)->cap = size; } - result = (GoUint32)SKY_api_Client_Transactions(arg1,arg2,arg3); + { + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_PasswordReader__Handle, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); + } else { + arg6 = *((PasswordReader__Handle *)(argp6)); + } + } + result = (GoUint32)SKY_cli_CreateRawTxFromAddress(arg1,arg2,arg3,arg4,arg5,arg6,arg7); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7)); } return resultobj; fail: @@ -16505,38 +16331,81 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Transactions(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_api_Client_ConfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + WebRpcClient__Handle arg1 ; + Wallet__Handle arg2 ; + GoSlice arg3 ; + GoString arg4 ; + GoSlice arg5 ; + GoSlice arg6 ; + Transaction__Handle *arg7 = (Transaction__Handle *) 0 ; + Handle temp7 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; GoUint32 result; { - arg3 = &temp3; + arg7 = &temp7; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_ConfirmedTransactions",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_ConfirmedTransactions', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + (&arg3)->data = buffer; + (&arg3)->len = size - 1; + (&arg3)->cap = size; } - result = (GoUint32)SKY_api_Client_ConfirmedTransactions(arg1,arg2,arg3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); + } + (&arg4)->p = buffer; + (&arg4)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); + } + (&arg5)->data = buffer; + (&arg5)->len = size - 1; + (&arg5)->cap = size; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); + } + (&arg6)->data = buffer; + (&arg6)->len = size - 1; + (&arg6)->cap = size; + } + result = (GoUint32)SKY_cli_CreateRawTx(arg1,arg2,arg3,arg4,arg5,arg6,arg7); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7)); } return resultobj; fail: @@ -16544,38 +16413,59 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_ConfirmedTransactions(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_api_Client_UnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_NewTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + GoSlice arg1 ; GoSlice arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoSlice arg3 ; + Transaction__Handle *arg4 = (Transaction__Handle *) 0 ; + Handle temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - arg3 = &temp3; + arg4 = &temp4; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnconfirmedTransactions",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_NewTransaction",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnconfirmedTransactions', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); } (&arg2)->data = buffer; (&arg2)->len = size - 1; (&arg2)->cap = size; } - result = (GoUint32)SKY_api_Client_UnconfirmedTransactions(arg1,arg2,arg3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); + } + (&arg3)->data = buffer; + (&arg3)->len = size - 1; + (&arg3)->cap = size; + } + result = (GoUint32)SKY_cli_NewTransaction(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); } return resultobj; fail: @@ -16583,33 +16473,35 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UnconfirmedTransactions(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_file_InitDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Transaction__Handle arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString temp3 ; + GoString arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_InitDataDir",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj1, (long*)&arg2); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_InitDataDir', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_api_Client_InjectTransaction(arg1,arg2,arg3); + result = (GoUint32)SKY_file_InitDataDir(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -16617,25 +16509,23 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_api_Client_ResendUnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; - PyObject * obj0 = 0 ; +SWIGINTERN PyObject *_wrap_SKY_file_UserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoString_ *arg1 = (GoString_ *) 0 ; + GoString temp1 ; GoUint32 result; { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_ResendUnconfirmedTransactions",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.p = NULL; + temp1.n = 0; + arg1 = (GoString_ *)&temp1; } - result = (GoUint32)SKY_api_Client_ResendUnconfirmedTransactions(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)":SKY_file_UserHome")) SWIG_fail; + result = (GoUint32)SKY_file_UserHome(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); + free( (void*)arg1->p ); } return resultobj; fail: @@ -16643,40 +16533,35 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_ResendUnconfirmedTransactions(PyObject } -SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_file_ResolveResourceDirectory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString temp3 ; + GoString arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_RawTransaction",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_file_ResolveResourceDirectory",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_RawTransaction', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_ResolveResourceDirectory', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_api_Client_RawTransaction(arg1,arg2,arg3); + result = (GoUint32)SKY_file_ResolveResourceDirectory(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -16684,37 +16569,59 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_file_DetermineResourcePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; + GoString arg1 ; GoString arg2 ; - Handle *arg3 = (Handle *) 0 ; - Handle temp3 ; + GoString arg3 ; + GoString_ *arg4 = (GoString_ *) 0 ; + GoString temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp4.p = NULL; + temp4.n = 0; + arg4 = (GoString_ *)&temp4; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressTransactions",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_file_DetermineResourcePath",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressTransactions', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; } - result = (GoUint32)SKY_api_Client_AddressTransactions(arg1,arg2,arg3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_file_DetermineResourcePath', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + result = (GoUint32)SKY_file_DetermineResourcePath(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); + free( (void*)arg4->p ); } return resultobj; fail: @@ -16722,34 +16629,25 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressTransactions(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Richlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_NewWalletResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - api__RichlistParams *arg2 = (api__RichlistParams *) 0 ; - Handle *arg3 = (Handle *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - Handle temp3 ; + Wallet__Handle arg1 ; + WalletResponse__Handle *arg2 = (WalletResponse__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Richlist",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewWalletResponse",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__RichlistParams, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_Richlist" "', argument " "2"" of type '" "api__RichlistParams *""'"); - } - arg2 = (api__RichlistParams *)(argp2); - result = (GoUint32)SKY_api_Client_Richlist(arg1,arg2,arg3); + result = (GoUint32)SKY_api_NewWalletResponse(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -16757,26 +16655,35 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_Richlist(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_CryptoTypeFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + GoString arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_AddressCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_CryptoTypeFromString",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CryptoTypeFromString', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_api_Client_AddressCount(arg1,arg2); + result = (GoUint32)SKY_wallet_CryptoTypeFromString(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -16784,29 +16691,21 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressCount(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_api_Client_UnloadWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; + wallet__Entry *arg1 = (wallet__Entry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnloadWallet",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnloadWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_Verify",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_Verify" "', argument " "1"" of type '" "wallet__Entry *""'"); } - result = (GoUint32)SKY_api_Client_UnloadWallet(arg1,arg2); + arg1 = (wallet__Entry *)(argp1); + result = (GoUint32)SKY_wallet_Entry_Verify(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -16814,75 +16713,79 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_UnloadWallet(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_api_Client_Health(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_VerifyPublic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - Handle *arg2 = (Handle *) 0 ; - Handle temp2 ; + wallet__Entry *arg1 = (wallet__Entry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; GoUint32 result; - { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Health",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_VerifyPublic",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_VerifyPublic" "', argument " "1"" of type '" "wallet__Entry *""'"); } - result = (GoUint32)SKY_api_Client_Health(arg1,arg2); + arg1 = (wallet__Entry *)(argp1); + result = (GoUint32)SKY_wallet_Entry_VerifyPublic(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Client_EncryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ; - Handle temp4 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + GoString_ *arg1 = (GoString_ *) 0 ; + GoString temp1 ; GoUint32 result; { - arg4 = &temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_EncryptWallet",&obj0,&obj1,&obj2)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.p = NULL; + temp1.n = 0; + arg1 = (GoString_ *)&temp1; } + if (!PyArg_ParseTuple(args,(char *)":SKY_bip39_NewDefaultMnemomic")) SWIG_fail; + result = (GoUint32)SKY_bip39_NewDefaultMnemomic(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); + free( (void*)arg1->p ); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + GoInt arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + long long val1 ; + int ecode1 = 0 ; + GoSlice_ temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - result = (GoUint32)SKY_api_Client_EncryptWallet(arg1,arg2,arg3,arg4); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewEntropy",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_bip39_NewEntropy" "', argument " "1"" of type '" "GoInt""'"); + } + arg1 = (GoInt)(val1); + result = (GoUint32)SKY_bip39_NewEntropy(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -16890,49 +16793,36 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_EncryptWallet(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ; - Handle temp4 ; + GoSlice arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - arg4 = &temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_DecryptWallet",&obj0,&obj1,&obj2)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewMnemonic",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_NewMnemonic', expecting string"); } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_api_Client_DecryptWallet(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_bip39_NewMnemonic(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -16940,43 +16830,36 @@ SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; - GoString arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - Handle temp1 ; - GoString temp3 ; + GoString arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg1 = &temp1; - } - { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_Get",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_MnemonicToByteArray",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_Get', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_MnemonicToByteArray', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_map_Get(arg1,arg2,arg3); + result = (GoUint32)SKY_bip39_MnemonicToByteArray(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -16984,32 +16867,34 @@ SWIGINTERN PyObject *_wrap_SKY_map_Get(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; - GoString arg2 ; - Handle temp1 ; + GoString arg1 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - GoUint8 result; + GoUint32 result; - { - arg1 = &temp1; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_map_HasKey",&obj0)) SWIG_fail; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_IsMnemonicValid",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_map_HasKey', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_IsMnemonicValid', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint8)SKY_map_HasKey(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + result = (GoUint32)SKY_bip39_IsMnemonicValid(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -17017,86 +16902,103 @@ SWIGINTERN PyObject *_wrap_SKY_map_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SKY_map_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoStringMap_ *arg1 = (GoStringMap_ *) 0 ; - Handle temp1 ; + httphelper__Address *arg1 = (httphelper__Address *) 0 ; + GoSlice arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - arg1 = &temp1; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_httphelper_Address_UnmarshalJSON",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_UnmarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); } - if (!PyArg_ParseTuple(args,(char *)":SKY_map_Close")) SWIG_fail; - result = (GoUint32)SKY_map_Close(arg1); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + arg1 = (httphelper__Address *)(argp1); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Address_UnmarshalJSON', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } + result = (GoUint32)SKY_httphelper_Address_UnmarshalJSON(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Address_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoInterface arg1 ; - void *argp1 ; + httphelper__Address *arg1 = (httphelper__Address *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + void *argp1 = 0 ; int res1 = 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewError",&obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_GoInterface, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_wallet_NewError" "', argument " "1"" of type '" "GoInterface""'"); - } else { - arg1 = *((GoInterface *)(argp1)); - } + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - result = (GoUint32)SKY_wallet_NewError(arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Address_MarshalJSON",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_httphelper__Address, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_httphelper_Address_MarshalJSON" "', argument " "1"" of type '" "httphelper__Address *""'"); + } + arg1 = (httphelper__Address *)(argp1); + result = (GoUint32)SKY_httphelper_Address_MarshalJSON(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - Options__Handle arg2 ; - Wallet__Handle *arg3 = (Wallet__Handle *) 0 ; - Handle temp3 ; + httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; + GoSlice arg2 ; + GoUint64 temp1 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp1 = 0; + arg1 = &temp1; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewWallet",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Coins_UnmarshalJSON",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewWallet', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Coins_UnmarshalJSON', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; - } - { - SWIG_AsVal_long(obj1, (long*)&arg2); + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_wallet_NewWallet(arg1,arg2,arg3); + result = (GoUint32)SKY_httphelper_Coins_UnmarshalJSON(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); } return resultobj; fail: @@ -17104,81 +17006,64 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewWallet(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Lock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoSlice arg2 ; - GoString arg3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoUint64 temp1 ; + GoSlice_ temp2 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_Lock",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1 = 0; + arg1 = &temp1; } { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_MarshalJSON")) SWIG_fail; + result = (GoUint32)SKY_httphelper_Coins_MarshalJSON(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Lock', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } - result = (GoUint32)SKY_wallet_Wallet_Lock(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Coins_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoSlice arg2 ; - Wallet__Handle *arg3 = (Wallet__Handle *) 0 ; - Handle temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + httphelper__Coins *arg1 = (httphelper__Coins *) 0 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp1 ; + GoUint64 temp2 ; GoUint32 result; { - arg3 = &temp3; + temp1 = 0; + arg1 = &temp1; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Unlock",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2 = 0; + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Coins_Value")) SWIG_fail; + result = (GoUint32)SKY_httphelper_Coins_Value(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Unlock', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); } - result = (GoUint32)SKY_wallet_Wallet_Unlock(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -17186,32 +17071,34 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Unlock(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_wallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_UnmarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - Wallet__Handle *arg2 = (Wallet__Handle *) 0 ; - Handle temp2 ; + httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; + GoSlice arg2 ; + GoUint64 temp1 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp1 = 0; + arg1 = &temp1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Load",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_httphelper_Hours_UnmarshalJSON",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Load', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_httphelper_Hours_UnmarshalJSON', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_wallet_Load(arg1,arg2); + result = (GoUint32)SKY_httphelper_Hours_UnmarshalJSON(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); } return resultobj; fail: @@ -17219,76 +17106,97 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_MarshalJSON(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString arg2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoUint64 temp1 ; + GoSlice_ temp2 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_Save",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1 = 0; + arg1 = &temp1; } { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_Wallet_Save', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - result = (GoUint32)SKY_wallet_Wallet_Save(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_MarshalJSON")) SWIG_fail; + result = (GoUint32)SKY_httphelper_Hours_MarshalJSON(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_httphelper_Hours_Value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - PyObject * obj0 = 0 ; + httphelper__Hours *arg1 = (httphelper__Hours *) 0 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp1 ; + GoUint64 temp2 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Validate",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1 = 0; + arg1 = &temp1; } - result = (GoUint32)SKY_wallet_Wallet_Validate(arg1); + { + temp2 = 0; + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)":SKY_httphelper_Hours_Value")) SWIG_fail; + result = (GoUint32)SKY_httphelper_Hours_Value(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg1 )); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoString arg1 ; + WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Type",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_NewClient",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_NewClient', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_wallet_Wallet_Type(arg1,arg2); + result = (GoUint32)SKY_webrpc_NewClient(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -17296,9 +17204,9 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Type(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; + WebRpcClient__Handle arg1 ; GoString_ *arg2 = (GoString_ *) 0 ; GoString temp2 ; PyObject * obj0 = 0 ; @@ -17309,11 +17217,11 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(se temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Version",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_Client_CSRF",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_Wallet_Version(arg1,arg2); + result = (GoUint32)SKY_webrpc_Client_CSRF(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); @@ -17325,28 +17233,33 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Version(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + WebRpcClient__Handle arg1 ; + Transaction__Handle arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Filename",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_Wallet_Filename(arg1,arg2); + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } + result = (GoUint32)SKY_webrpc_Client_InjectTransaction(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -17354,70 +17267,77 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Filename(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_Label(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + WebRpcClient__Handle arg1 ; + StatusResult_Handle *arg2 = (StatusResult_Handle *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_Label",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetStatus",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_Wallet_Label(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StatusResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_webrpc_Client_GetStatus" "', argument " "2"" of type '" "StatusResult_Handle *""'"); } + arg2 = (StatusResult_Handle *)(argp2); + result = (GoUint32)SKY_webrpc_Client_GetStatus(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_IsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetTransactionByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + WebRpcClient__Handle arg1 ; + GoString arg2 ; + TransactionResult_Handle *arg3 = (TransactionResult_Handle *) 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_IsEncrypted",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetTransactionByID",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_Wallet_IsEncrypted(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetTransactionByID', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_TransactionResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_webrpc_Client_GetTransactionByID" "', argument " "3"" of type '" "TransactionResult_Handle *""'"); } + arg3 = (TransactionResult_Handle *)(argp3); + result = (GoUint32)SKY_webrpc_Client_GetTransactionByID(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoUint64 arg2 ; + WebRpcClient__Handle arg1 ; + GoSlice arg2 ; coin__UxArray *arg3 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; GoSlice_ temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; @@ -17429,16 +17349,22 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNU temp3.cap = 0; arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_GenerateAddresses",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetAddressUxOuts",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_Wallet_GenerateAddresses" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_wallet_Wallet_GenerateAddresses(arg1,arg2,arg3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetAddressUxOuts', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; + } + result = (GoUint32)SKY_webrpc_Client_GetAddressUxOuts(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); @@ -17450,29 +17376,47 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GenerateAddresses(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + WebRpcClient__Handle arg1 ; + GoUint64 arg2 ; + GoUint64 arg3 ; + coin__UxArray *arg4 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + unsigned long long val3 ; + int ecode3 = 0 ; + GoSlice_ temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp4.data = NULL; + temp4.len = 0; + temp4.cap = 0; + arg4 = (coin__UxArray *)&temp4; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Wallet_GetAddresses",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetBlocksInRange",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_Wallet_GetAddresses(arg1,arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "3"" of type '" "GoUint64""'"); + } + arg3 = (GoUint64)(val3); + result = (GoUint32)SKY_webrpc_Client_GetBlocksInRange(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); + free( (void*)arg4->data ); } return resultobj; fail: @@ -17480,45 +17424,42 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetAddresses(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - wallet__Entry *arg3 = (wallet__Entry *) 0 ; - GoUint8 *arg4 = (GoUint8 *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - GoUint8 temp4 ; - int res4 = SWIG_TMPOBJ ; + WebRpcClient__Handle arg1 ; + GoSlice arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - arg4 = &temp4; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Wallet_GetEntry",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "2"" of type '" "cipher__Address *""'"); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetBlocksBySeq",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg2 = (cipher__Address *)(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Entry, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Wallet_GetEntry" "', argument " "3"" of type '" "wallet__Entry *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetBlocksBySeq', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - arg3 = (wallet__Entry *)(argp3); - result = (GoUint32)SKY_wallet_Wallet_GetEntry(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_webrpc_Client_GetBlocksBySeq(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res4)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); - } else { - int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -17526,96 +17467,137 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_GetEntry(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_wallet_Wallet_AddEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - wallet__Entry *arg2 = (wallet__Entry *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + WebRpcClient__Handle arg1 ; + GoUint64 arg2 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoSlice_ temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Wallet_AddEntry",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Wallet_AddEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetLastBlocks",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg2 = (wallet__Entry *)(argp2); - result = (GoUint32)SKY_wallet_Wallet_AddEntry(arg1,arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetLastBlocks" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_webrpc_Client_GetLastBlocks(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_CreateOptionsHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint64 arg2 ; - GoUint8 arg3 ; - GoUint64 *arg4 = (GoUint64 *) 0 ; - coin__UxArray *arg5 = (coin__UxArray *) 0 ; - GoUint64 *arg6 = (GoUint64 *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned char val3 ; - int ecode3 = 0 ; - GoUint64 temp4 ; - GoSlice_ temp5 ; - GoUint64 temp6 ; + GoString arg1 ; + GoString arg2 ; + GoString arg3 ; + GoUint8 arg4 ; + GoString arg5 ; + GoString arg6 ; + GoUint64 arg7 ; + Options__Handle *arg8 = (Options__Handle *) 0 ; + unsigned char val4 ; + int ecode4 = 0 ; + unsigned long long val7 ; + int ecode7 = 0 ; + Handle temp8 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; GoUint32 result; { - temp4 = 0; - arg4 = &temp4; + arg8 = &temp8; } + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:SKY_wallet_CreateOptionsHandle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; { - temp5.data = NULL; - temp5.len = 0; - temp5.cap = 0; - arg5 = (coin__UxArray *)&temp5; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } { - temp6 = 0; - arg6 = &temp6; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_DistributeSpendHours",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_DistributeSpendHours" "', argument " "3"" of type '" "GoUint8""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "4"" of type '" "GoUint8""'"); } - arg3 = (GoUint8)(val3); - result = (GoUint32)SKY_wallet_DistributeSpendHours(arg1,arg2,arg3,arg4,arg5,arg6); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + arg4 = (GoUint8)(val4); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg4 )); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); + } + (&arg5)->p = buffer; + (&arg5)->n = size - 1; } { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len )); - free( (void*)arg5->data ); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_CreateOptionsHandle', expecting string"); + } + (&arg6)->p = buffer; + (&arg6)->n = size - 1; } + ecode7 = SWIG_AsVal_unsigned_SS_long_SS_long(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SKY_wallet_CreateOptionsHandle" "', argument " "7"" of type '" "GoUint64""'"); + } + arg7 = (GoUint64)(val7); + result = (GoUint32)SKY_wallet_CreateOptionsHandle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg6 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg8)); } return resultobj; fail: @@ -17623,188 +17605,87 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeSpendHours(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_wallet_DistributeCoinHoursProportional(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoUint64 arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - GoSlice_ temp3 ; + App__Handle arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_App_Run",&obj0,&obj1)) SWIG_fail; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_DistributeCoinHoursProportional",&obj0,&obj1)) SWIG_fail; { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_DistributeCoinHoursProportional', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_App_Run', expecting string"); } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_DistributeCoinHoursProportional" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_wallet_DistributeCoinHoursProportional(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_App_Run(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalances(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetCoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - GoSlice_ temp2 ; - GoSlice_ temp3 ; + Config__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetCoin",&obj0)) SWIG_fail; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_NewUxBalances",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalances" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - result = (GoUint32)SKY_wallet_NewUxBalances(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_Config_GetCoin(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_wallet_NewUxBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoUint64 arg1 ; - coin__UxOut *arg2 = (coin__UxOut *) 0 ; - wallet__UxBalance *arg3 = (wallet__UxBalance *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewUxBalance",&obj0,&obj1,&obj2)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewUxBalance" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewUxBalance" "', argument " "2"" of type '" "coin__UxOut *""'"); - } - arg2 = (coin__UxOut *)(argp2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__UxBalance, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewUxBalance" "', argument " "3"" of type '" "wallet__UxBalance *""'"); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } - arg3 = (wallet__UxBalance *)(argp3); - result = (GoUint32)SKY_wallet_NewUxBalance(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoUint64 arg2 ; - GoUint64 arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned long long val3 ; - int ecode3 = 0 ; - GoSlice_ temp4 ; + Config__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMinimizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetRPCAddress",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMinimizeUxOuts', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMinimizeUxOuts" "', argument " "3"" of type '" "GoUint64""'"); - } - arg3 = (GoUint64)(val3); - result = (GoUint32)SKY_wallet_ChooseSpendsMinimizeUxOuts(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_cli_Config_GetRPCAddress(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -17812,55 +17693,25 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoUint64 arg2 ; - GoUint64 arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - unsigned long long val3 ; - int ecode3 = 0 ; - GoSlice_ temp4 ; + App__Handle arg1 ; + WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_ChooseSpendsMaximizeUxOuts",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromApp",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ChooseSpendsMaximizeUxOuts', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_wallet_ChooseSpendsMaximizeUxOuts" "', argument " "3"" of type '" "GoUint64""'"); - } - arg3 = (GoUint64)(val3); - result = (GoUint32)SKY_wallet_ChooseSpendsMaximizeUxOuts(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_cli_RPCClientFromApp(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -17868,96 +17719,112 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58BitcoinAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Getenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoString arg1 ; - cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58BitcoinAddress",&obj0,&obj1)) SWIG_fail; + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Getenv",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58BitcoinAddress', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Getenv', expecting string"); } (&arg1)->p = buffer; (&arg1)->n = size - 1; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58BitcoinAddress" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); - } - arg2 = (cipher__BitcoinAddress *)(argp2); - result = (GoUint32)SKY_cipher_DecodeBase58BitcoinAddress(arg1,arg2); + result = (GoUint32)SKY_cli_Getenv(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + GoString arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromPubKey",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_Setenv",&obj0,&obj1)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromPubKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - arg2 = (cipher__BitcoinAddress *)(argp2); - SKY_cipher_BitcoinAddressFromPubKey((unsigned char (*)[33])arg1,arg2); - resultobj = SWIG_Py_Void(); + result = (GoUint32)SKY_cli_Setenv(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; - cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + GoUint64 arg1 ; + GoUint64 arg2 ; + wallet__Balance *arg3 = (wallet__Balance *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromSecKey",&obj0,&obj1)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromSecKey" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalance",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalance" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_wallet_NewBalance" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalance" "', argument " "3"" of type '" "wallet__Balance *""'"); } - arg2 = (cipher__BitcoinAddress *)(argp2); - result = (GoUint32)SKY_cipher_BitcoinAddressFromSecKey((unsigned char (*)[32])arg1,arg2); + arg3 = (wallet__Balance *)(argp3); + result = (GoUint32)SKY_wallet_NewBalance(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -17965,67 +17832,79 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromSecKey(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewBalanceFromUxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoUint64 arg1 ; + coin__UxOut *arg2 = (coin__UxOut *) 0 ; + wallet__Balance *arg3 = (wallet__Balance *) 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + GoUint32 result; - { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinWalletImportFormatFromSeckey",&obj0)) SWIG_fail; - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_NewBalanceFromUxOut",&obj0,&obj1,&obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "2"" of type '" "coin__UxOut *""'"); } - SKY_cipher_BitcoinWalletImportFormatFromSeckey((unsigned char (*)[32])arg1,arg2); - resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + arg2 = (coin__UxOut *)(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_NewBalanceFromUxOut" "', argument " "3"" of type '" "wallet__Balance *""'"); } + arg3 = (wallet__Balance *)(argp3); + result = (GoUint32)SKY_wallet_NewBalanceFromUxOut(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__BitcoinAddress *arg2 = (cipher__BitcoinAddress *) 0 ; + wallet__Balance *arg1 = (wallet__Balance *) 0 ; + wallet__Balance *arg2 = (wallet__Balance *) 0 ; + wallet__Balance *arg3 = (wallet__Balance *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddressFromBytes",&obj0,&obj1)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_BitcoinAddressFromBytes', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Add",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Add" "', argument " "1"" of type '" "wallet__Balance *""'"); } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + arg1 = (wallet__Balance *)(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_BitcoinAddressFromBytes" "', argument " "2"" of type '" "cipher__BitcoinAddress *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Add" "', argument " "2"" of type '" "wallet__Balance *""'"); } - arg2 = (cipher__BitcoinAddress *)(argp2); - result = (GoUint32)SKY_cipher_BitcoinAddressFromBytes(arg1,arg2); + arg2 = (wallet__Balance *)(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Add" "', argument " "3"" of type '" "wallet__Balance *""'"); + } + arg3 = (wallet__Balance *)(argp3); + result = (GoUint32)SKY_wallet_Balance_Add(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18033,34 +17912,39 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddressFromBytes(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - cipher__SecKey *arg2 = (cipher__SecKey *) 0 ; + wallet__Balance *arg1 = (wallet__Balance *) 0 ; + wallet__Balance *arg2 = (wallet__Balance *) 0 ; + wallet__Balance *arg3 = (wallet__Balance *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SecKeyFromBitcoinWalletImportFormat",&obj0,&obj1)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SecKeyFromBitcoinWalletImportFormat', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_wallet_Balance_Sub",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Sub" "', argument " "1"" of type '" "wallet__Balance *""'"); } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg2 = &p->data; + arg1 = (wallet__Balance *)(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Sub" "', argument " "2"" of type '" "wallet__Balance *""'"); } - result = (GoUint32)SKY_cipher_SecKeyFromBitcoinWalletImportFormat(arg1,(unsigned char (*)[32])arg2); + arg2 = (wallet__Balance *)(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_wallet_Balance_Sub" "', argument " "3"" of type '" "wallet__Balance *""'"); + } + arg3 = (wallet__Balance *)(argp3); + result = (GoUint32)SKY_wallet_Balance_Sub(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18068,54 +17952,72 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat(PyObje } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_Equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + wallet__Balance *arg1 = (wallet__Balance *) 0 ; + wallet__Balance *arg2 = (wallet__Balance *) 0 ; + GoUint8 *arg3 = (GoUint8 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + GoUint8 temp3 ; + int res3 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - GoUint8 result; + PyObject * obj1 = 0 ; + GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Null",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_Balance_Equals",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Null" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_Equals" "', argument " "1"" of type '" "wallet__Balance *""'"); + } + arg1 = (wallet__Balance *)(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Balance, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_Balance_Equals" "', argument " "2"" of type '" "wallet__Balance *""'"); + } + arg2 = (wallet__Balance *)(argp2); + result = (GoUint32)SKY_wallet_Balance_Equals(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res3)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); + } else { + int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags)); } - arg1 = (cipher__BitcoinAddress *)(argp1); - result = (GoUint8)SKY_cipher_BitcoinAddress_Null(arg1); - resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_Balance_IsZero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; + wallet__Balance *arg1 = (wallet__Balance *) 0 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - GoSlice_ temp2 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; + GoUint32 result; - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_Bytes",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Balance_IsZero",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Balance, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Bytes" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Balance_IsZero" "', argument " "1"" of type '" "wallet__Balance *""'"); } - arg1 = (cipher__BitcoinAddress *)(argp1); - SKY_cipher_BitcoinAddress_Bytes(arg1,arg2); - resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + arg1 = (wallet__Balance *)(argp1); + result = (GoUint32)SKY_wallet_Balance_IsZero(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -18123,60 +18025,63 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Bytes(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_droplet_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + GoString arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Verify",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Verify" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); + { + temp2 = 0; + arg2 = &temp2; } - arg1 = (cipher__BitcoinAddress *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_FromString",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_droplet_FromString', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_cipher_BitcoinAddress_Verify(arg1,(unsigned char (*)[33])arg2); + result = (GoUint32)SKY_droplet_FromString(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_droplet_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; + GoUint64 arg1 ; GoString_ *arg2 = (GoString_ *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + unsigned long long val1 ; + int ecode1 = 0 ; GoString temp2 ; PyObject * obj0 = 0 ; + GoUint32 result; { temp2.p = NULL; temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_BitcoinAddress_String",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_String" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); - } - arg1 = (cipher__BitcoinAddress *)(argp1); - SKY_cipher_BitcoinAddress_String(arg1,arg2); - resultobj = SWIG_Py_Void(); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_droplet_ToString",&obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_droplet_ToString" "', argument " "1"" of type '" "GoUint64""'"); + } + arg1 = (GoUint64)(val1); + result = (GoUint32)SKY_droplet_ToString(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); free( (void*)arg2->p ); @@ -18187,51 +18092,41 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_String(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_cipher_BitcoinAddress_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__BitcoinAddress *arg1 = (cipher__BitcoinAddress *) 0 ; - cipher__Checksum *arg2 = (cipher__Checksum *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + GoString arg1 ; + wallet__Entry *arg2 = (wallet__Entry *) 0 ; + ReadableEntry__Handle *arg3 = (ReadableEntry__Handle *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_BitcoinAddress_Checksum",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__BitcoinAddress, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_BitcoinAddress_Checksum" "', argument " "1"" of type '" "cipher__BitcoinAddress *""'"); - } - arg1 = (cipher__BitcoinAddress *)(argp1); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum"); - cipher_Checksum* p = (cipher_Checksum*)argp; - arg2 = &p->data; + arg3 = &temp3; } - SKY_cipher_BitcoinAddress_Checksum(arg1,(unsigned char (*)[4])arg2); - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle *arg1 = (Transaction__Handle *) 0 ; - Handle temp1 ; - GoUint32 result; - + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewReadableEntry",&obj0,&obj1)) SWIG_fail; { - arg1 = &temp1; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewReadableEntry', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transaction")) SWIG_fail; - result = (GoUint32)SKY_coin_Create_Transaction(arg1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewReadableEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); + } + arg2 = (wallet__Entry *)(argp2); + result = (GoUint32)SKY_wallet_NewReadableEntry(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -18239,10 +18134,10 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transaction(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; + GoString arg1 ; + ReadableWallet__Handle *arg2 = (ReadableWallet__Handle *) 0 ; Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -18250,11 +18145,18 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(se { arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Copy",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_LoadReadableWallet",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_LoadReadableWallet', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - result = (GoUint32)SKY_coin_Transaction_Copy(arg1,arg2); + result = (GoUint32)SKY_wallet_LoadReadableWallet(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); @@ -18265,53 +18167,59 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Copy(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - coin__Transaction **arg2 = (coin__Transaction **) 0 ; - coin__Transaction *temp2 ; + ReadableWallet__Handle arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - { - temp2 = NULL; - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_GetTransactionObject",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Save",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_GetTransactionObject(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_coin__Transaction, 0 )); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Save', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } + result = (GoUint32)SKY_wallet_ReadableWallet_Save(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetInputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - long long val2 ; - int ecode2 = 0 ; + ReadableWallet__Handle arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetInputs",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Load",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Load', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetInputs" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_coin_Transaction_ResetInputs(arg1,arg2); + result = (GoUint32)SKY_wallet_ReadableWallet_Load(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18319,129 +18227,96 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetInputs(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; + ReadableWallet__Handle arg1 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetInputsCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_ReadableWallet_Erase",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_Transaction_GetInputsCount(arg1,arg2); + result = (GoUint32)SKY_wallet_ReadableWallet_Erase(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_LoadConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; - long long val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + Config__Handle *arg1 = (Config__Handle *) 0 ; + Handle temp1 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetInputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg1 = &temp1; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetInputAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); + if (!PyArg_ParseTuple(args,(char *)":SKY_cli_LoadConfig")) SWIG_fail; + result = (GoUint32)SKY_cli_LoadConfig(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); } - result = (GoUint32)SKY_coin_Transaction_GetInputAt(arg1,arg2,(unsigned char (*)[32])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetInputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullWalletPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; - long long val2 ; - int ecode2 = 0 ; + Config__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetInputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetInputAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullWalletPath",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_Transaction_SetInputAt(arg1,arg2,(unsigned char (*)[32])arg3); + result = (GoUint32)SKY_cli_Config_FullWalletPath(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_Config_FullDBPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; + Config__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetOutputsCount",&obj0)) SWIG_fail; + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_FullDBPath",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_Transaction_GetOutputsCount(arg1,arg2); + result = (GoUint32)SKY_cli_Config_FullDBPath(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -18449,99 +18324,77 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputsCount(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_NewApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ; - long long val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Config__Handle arg1 ; + App__Handle *arg2 = (App__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg2 = &temp2; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_GetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_NewApp",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg3 = (coin__TransactionOutput *)(argp3); - result = (GoUint32)SKY_coin_Transaction_GetOutputAt(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_NewApp(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetOutputAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - coin__TransactionOutput *arg3 = (coin__TransactionOutput *) 0 ; - long long val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Context__Handle arg1 ; + WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetOutputAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg2 = &temp2; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_Transaction_SetOutputAt" "', argument " "3"" of type '" "coin__TransactionOutput *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromContext",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg3 = (coin__TransactionOutput *)(argp3); - result = (GoUint32)SKY_coin_Transaction_SetOutputAt(arg1,arg2,arg3); + result = (GoUint32)SKY_cli_RPCClientFromContext(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_ConfigFromContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; + Context__Handle arg1 ; + Config__Handle *arg2 = (Config__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_GetSignaturesCount",&obj0)) SWIG_fail; + { + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_ConfigFromContext",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_Transaction_GetSignaturesCount(arg1,arg2); + result = (GoUint32)SKY_cli_ConfigFromContext(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -18549,101 +18402,93 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignaturesCount(PyObject *SWI } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_GetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromBytes_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - cipher__Sig *arg3 = (cipher__Sig *) 0 ; - long long val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; + GoSlice_ temp2 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_GetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_GetSignatureAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg3 = &p->data; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - result = (GoUint32)SKY_coin_Transaction_GetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3); + if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromBytes_Password")) SWIG_fail; + result = (GoUint32)SKY_cli_PasswordFromBytes_Password(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SetSignatureAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cli_PasswordFromTerm_Password(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - cipher__Sig *arg3 = (cipher__Sig *) 0 ; - long long val2 ; - int ecode2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_Transaction_SetSignatureAt",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_SetSignatureAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); + if (!PyArg_ParseTuple(args,(char *)":SKY_cli_PasswordFromTerm_Password")) SWIG_fail; + result = (GoUint32)SKY_cli_PasswordFromTerm_Password(arg1); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; - arg3 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); } - result = (GoUint32)SKY_coin_Transaction_SetSignatureAt(arg1,arg2,(unsigned char (*)[65])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushSignature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - cipher__Sig *arg2 = (cipher__Sig *) 0 ; + coin__UxOut *arg1 = (coin__UxOut *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushSignature",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_Hash",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_Hash" "', argument " "1"" of type '" "coin__UxOut *""'"); } + arg1 = (coin__UxOut *)(argp1); { void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Sig, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Sig"); - cipher_Sig* p = (cipher_Sig*)argp; + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; arg2 = &p->data; } - result = (GoUint32)SKY_coin_Transaction_PushSignature(arg1,(unsigned char (*)[65])arg2); + result = (GoUint32)SKY_coin_UxOut_Hash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18651,26 +18496,31 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushSignature(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_SnapshotHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - long long val2 ; - int ecode2 = 0 ; + coin__UxOut *arg1 = (coin__UxOut *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetOutputs",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_SnapshotHash",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_SnapshotHash" "', argument " "1"" of type '" "coin__UxOut *""'"); + } + arg1 = (coin__UxOut *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetOutputs" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_coin_Transaction_ResetOutputs(arg1,arg2); + result = (GoUint32)SKY_coin_UxOut_SnapshotHash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18678,26 +18528,31 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetOutputs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetSignatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxBody_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoInt arg2 ; - long long val2 ; - int ecode2 = 0 ; + coin__UxBody *arg1 = (coin__UxBody *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_ResetSignatures",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxBody_Hash",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxBody, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxBody_Hash" "', argument " "1"" of type '" "coin__UxBody *""'"); + } + arg1 = (coin__UxBody *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transaction_ResetSignatures" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_coin_Transaction_ResetSignatures(arg1,arg2); + result = (GoUint32)SKY_coin_UxBody_Hash(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -18705,44 +18560,73 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_ResetSignatures(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxOut_CoinHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; + coin__UxOut *arg1 = (coin__UxOut *) 0 ; + GoUint64 arg2 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Verify",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp3 = 0; + arg3 = &temp3; } - result = (GoUint32)SKY_coin_Transaction_Verify(arg1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxOut_CoinHours",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__UxOut, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "1"" of type '" "coin__UxOut *""'"); + } + arg1 = (coin__UxOut *)(argp1); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxOut_CoinHours" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_coin_UxOut_CoinHours(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; GoSlice_ temp2 ; - PyObject * obj0 = 0 ; GoUint32 result; + { + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; + } { temp2.data = NULL; temp2.len = 0; temp2.cap = 0; arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_VerifyInput",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Hashes")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Hashes(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - SWIG_AsVal_long(obj0, (long*)&arg1); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); } - result = (GoUint32)SKY_coin_Transaction_VerifyInput(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); free( (void*)arg2->data ); @@ -18753,82 +18637,127 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_VerifyInput(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Hashes(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[2] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { + for (ii = 0; (ii < 1) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } + if (argc == 0) { + return _wrap_SKY_coin_UxArray_Hashes__SWIG_1(self, args); + } if (argc == 1) { int _v; { - _v = PyInt_Check(argv[0]) ? 1 : 0; + _v = PyList_Check(argv[0]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_1(self, args); + return _wrap_SKY_coin_UxArray_Hashes__SWIG_0(self, args); } } - if (argc == 2) { + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Hashes'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_Hashes(coin_UxOutArray *,cipher_SHA256s *)\n" + " SKY_coin_UxArray_Hashes(coin__UxArray *,coin__UxArray *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoSlice_ temp1 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; + GoUint32 result; + + { + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; + } + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_HasDupes")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_HasDupes(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_HasDupes(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 0) { + return _wrap_SKY_coin_UxArray_HasDupes__SWIG_1(self, args); + } + if (argc == 1) { int _v; { - _v = PyInt_Check(argv[0]) ? 1 : 0; + _v = PyList_Check(argv[0]) ? 1 : 0; } if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_SKY_coin_Transaction_VerifyInput__SWIG_0(self, args); - } + return _wrap_SKY_coin_UxArray_HasDupes__SWIG_0(self, args); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_VerifyInput'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_HasDupes'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin_UxOutArray *)\n" - " SKY_coin_Transaction_VerifyInput(Transaction__Handle,coin__UxArray *)\n"); + " wrap_SKY_coin_UxArray_HasDupes(coin_UxOutArray *,GoUint8 *)\n" + " SKY_coin_UxArray_HasDupes(coin__UxArray *,GoUint8 *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - GoUint16 *arg3 = (GoUint16 *) 0 ; - GoUint16 temp3 ; - int res3 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; GoUint32 result; - arg3 = &temp3; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_PushInput",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - result = (GoUint32)SKY_coin_Transaction_PushInput(arg1,(unsigned char (*)[32])arg2,arg3); + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sort")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Sort(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res3)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); - } else { - int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); } return resultobj; fail: @@ -18836,433 +18765,359 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushInput(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SKY_coin_TransactionOutput_UxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__TransactionOutput *arg1 = (coin__TransactionOutput *) 0 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoInt *arg2 = (GoInt *) 0 ; + GoSlice_ temp1 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_TransactionOutput_UxID",&obj0,&obj1,&obj2)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_coin__TransactionOutput, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_TransactionOutput_UxID" "', argument " "1"" of type '" "coin__TransactionOutput *""'"); - } - arg1 = (coin__TransactionOutput *)(argp1); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Len")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Len(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - void *argp = 0; - int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } - result = (GoUint32)SKY_coin_TransactionOutput_UxID(arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_PushOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - GoUint64 arg3 ; - GoUint64 arg4 ; - void *argp2 = 0 ; - int res2 = 0 ; - unsigned long long val3 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoInt arg2 ; + GoInt arg3 ; + GoUint8 *arg4 = (GoUint8 *) 0 ; + GoSlice_ temp1 ; + long long val2 ; + int ecode2 = 0 ; + long long val3 ; int ecode3 = 0 ; - unsigned long long val4 ; - int ecode4 = 0 ; + GoUint8 temp4 ; + int res4 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_coin_Transaction_PushOutput",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "2"" of type '" "cipher__Address *""'"); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - arg2 = (cipher__Address *)(argp2); - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "3"" of type '" "GoUint64""'"); + arg4 = &temp4; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Less",&obj0,&obj1)) SWIG_fail; + ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Less" "', argument " "2"" of type '" "GoInt""'"); } - arg3 = (GoUint64)(val3); - ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_coin_Transaction_PushOutput" "', argument " "4"" of type '" "GoUint64""'"); + arg2 = (GoInt)(val2); + ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Less" "', argument " "3"" of type '" "GoInt""'"); } - arg4 = (GoUint64)(val4); - result = (GoUint32)SKY_coin_Transaction_PushOutput(arg1,arg2,arg3,arg4); + arg3 = (GoInt)(val3); + result = (GoUint32)SKY_coin_UxArray_Less(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + if (SWIG_IsTmpObj(res4)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); + } else { + int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Less(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + Py_ssize_t ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 3) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_UxArray_Less__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_long_SS_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_UxArray_Less__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Less'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_Less(coin_UxOutArray *,GoInt,GoInt,GoUint8 *)\n" + " SKY_coin_UxArray_Less(coin__UxArray *,GoInt,GoInt,GoUint8 *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoSlice arg2 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoInt arg2 ; + GoInt arg3 ; + GoSlice_ temp1 ; + long long val2 ; + int ecode2 = 0 ; + long long val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SignInputs",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_Transaction_SignInputs', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - result = (GoUint32)SKY_coin_Transaction_SignInputs(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_UxArray_Swap",&obj0,&obj1)) SWIG_fail; + ecode2 = SWIG_AsVal_long_SS_long(obj0, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_Swap" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + ecode3 = SWIG_AsVal_long_SS_long(obj1, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_UxArray_Swap" "', argument " "3"" of type '" "GoInt""'"); + } + arg3 = (GoInt)(val3); + result = (GoUint32)SKY_coin_UxArray_Swap(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SignInputs(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Swap(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[4] = { 0 }; Py_ssize_t ii; if (!PyTuple_Check(args)) SWIG_fail; argc = args ? PyObject_Length(args) : 0; - for (ii = 0; (ii < 2) && (ii < argc); ii++) { + for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } if (argc == 2) { int _v; { - _v = PyInt_Check(argv[0]) ? 1 : 0; + int res = SWIG_AsVal_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); } if (_v) { { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( argv[1], &buffer, &size, 0 ); - _v = SWIG_IsOK(res) ? 1 : 0; + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SKY_coin_Transaction_SignInputs__SWIG_1(self, args); + return _wrap_SKY_coin_UxArray_Swap__SWIG_1(self, args); } } } - if (argc == 2) { + if (argc == 3) { int _v; { - _v = PyInt_Check(argv[0]) ? 1 : 0; + _v = PyList_Check(argv[0]) ? 1 : 0; } if (_v) { { - _v = PyList_Check(argv[1]) ? 1 : 0; + int res = SWIG_AsVal_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SKY_coin_Transaction_SignInputs__SWIG_0(self, args); + { + int res = SWIG_AsVal_long_SS_long(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_UxArray_Swap__SWIG_0(self, args); + } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transaction_SignInputs'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Swap'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_Transaction_SignInputs(Transaction__Handle,cipher_SecKeys *)\n" - " SKY_coin_Transaction_SignInputs(Transaction__Handle,GoSlice)\n"); + " wrap_SKY_coin_UxArray_Swap(coin_UxOutArray *,GoInt,GoInt)\n" + " SKY_coin_UxArray_Swap(coin__UxArray *,GoInt,GoInt)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - GoUint32 result; - - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Size",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_coin_Transaction_Size(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Hash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_Hash",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; - } - result = (GoUint32)SKY_coin_Transaction_Hash(arg1,(unsigned char (*)[32])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_SizeHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_SizeHash",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg3 = &p->data; - } - result = (GoUint32)SKY_coin_Transaction_SizeHash(arg1,arg2,(unsigned char (*)[32])arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; - - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxID",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_coin_Transaction_TxID(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_TxIDHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; - PyObject * obj0 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoSlice_ temp1 ; + GoUint64 temp2 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_TxIDHex",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_coin_Transaction_TxIDHex(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_UpdateHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - PyObject * obj0 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_UpdateHeader",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2 = 0; + arg2 = &temp2; } - result = (GoUint32)SKY_coin_Transaction_UpdateHeader(arg1); + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Coins")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Coins(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_HashInner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transaction_HashInner",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); } { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); - cipher_SHA256* p = (cipher_SHA256*)argp; - arg2 = &p->data; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } - result = (GoUint32)SKY_coin_Transaction_HashInner(arg1,(unsigned char (*)[32])arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_Serialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Coins(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; - { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_Serialize",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (argc == 0) { + return _wrap_SKY_coin_UxArray_Coins__SWIG_1(self, args); } - result = (GoUint32)SKY_coin_Transaction_Serialize(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + if (argc == 1) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_UxArray_Coins__SWIG_0(self, args); + } } - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Coins'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_Coins(coin_UxOutArray *,GoUint64 *)\n" + " SKY_coin_UxArray_Coins(coin__UxArray *,GoUint64 *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_TransactionDeserialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - Transaction__Handle *arg2 = (Transaction__Handle *) 0 ; - Handle temp2 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + GoUint64 arg2 ; + GoUint64 *arg3 = (GoUint64 *) 0 ; + GoSlice_ temp1 ; + unsigned long long val2 ; + int ecode2 = 0 ; + GoUint64 temp3 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_TransactionDeserialize",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_coin_TransactionDeserialize', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + temp3 = 0; + arg3 = &temp3; } - result = (GoUint32)SKY_coin_TransactionDeserialize(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_UxArray_CoinHours",&obj0)) SWIG_fail; + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_UxArray_CoinHours" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_coin_UxArray_CoinHours(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); } return resultobj; fail: @@ -19270,47 +19125,95 @@ SWIGINTERN PyObject *_wrap_SKY_coin_TransactionDeserialize(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_coin_Transaction_OutputHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transaction__Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_CoinHours(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; - { - temp2 = 0; - arg2 = &temp2; + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transaction_OutputHours",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_UxArray_CoinHours__SWIG_1(self, args); + } } - result = (GoUint32)SKY_coin_Transaction_OutputHours(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + if (argc == 2) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SKY_coin_UxArray_CoinHours__SWIG_0(self, args); + } + } } - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_CoinHours'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_CoinHours(coin_UxOutArray *,GoUint64,GoUint64 *)\n" + " SKY_coin_UxArray_CoinHours(coin__UxArray *,GoUint64,GoUint64 *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle *arg1 = (Transactions__Handle *) 0 ; - Handle temp1 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; + GoSlice_ temp2 ; + GoSlice_ temp3 ; GoUint32 result; { - arg1 = &temp1; + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_Create_Transactions")) SWIG_fail; - result = (GoUint32)SKY_coin_Create_Transactions(arg1); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + { + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; + } + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Sub")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Sub(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg1)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -19318,54 +19221,87 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Create_Transactions(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_coin_GetTransactionsObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - coin__UxArray **arg2 = (coin__UxArray **) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Sub(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_GetTransactionsObject",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_GoSlice_, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_GetTransactionsObject" "', argument " "2"" of type '" "coin__UxArray **""'"); + if (argc == 0) { + return _wrap_SKY_coin_UxArray_Sub__SWIG_1(self, args); } - arg2 = (coin__UxArray **)(argp2); - result = (GoUint32)SKY_coin_GetTransactionsObject(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; + if (argc == 2) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_UxArray_Sub__SWIG_0(self, args); + } + } + } + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Sub'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_Sub(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n" + " SKY_coin_UxArray_Sub(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + GoSlice_ temp1 ; + GoSlice_ temp2 ; + GoSlice_ temp3 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Length",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } - result = (GoUint32)SKY_coin_Transactions_Length(arg1,arg2); + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + { + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; + } + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_UxArray_Add")) SWIG_fail; + result = (GoUint32)SKY_coin_UxArray_Add(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -19373,58 +19309,71 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Length(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - Transaction__Handle arg2 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_UxArray_Add(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Add",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 2) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - { - SWIG_AsVal_long(obj1, (long*)&arg2); + if (argc == 0) { + return _wrap_SKY_coin_UxArray_Add__SWIG_1(self, args); } - result = (GoUint32)SKY_coin_Transactions_Add(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; + if (argc == 2) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_UxArray_Add__SWIG_0(self, args); + } + } + } + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_UxArray_Add'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_UxArray_Add(coin_UxOutArray *,coin_UxOutArray *,coin_UxOutArray *)\n" + " SKY_coin_UxArray_Add(coin__UxArray *,coin__UxArray *,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle arg1 ; - FeeCalculator *arg2 = (FeeCalculator *) 0 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - FeeCalculator temp2 ; - GoUint64 temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; + coin__UxArray *arg1 = (coin__UxArray *) 0 ; + AddressUxOuts_Handle *arg2 = (AddressUxOuts_Handle *) 0 ; + GoSlice_ temp1 ; + Handle temp2 ; GoUint32 result; { - temp3 = 0; - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_Fees",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp1.data = NULL; + temp1.len = 0; + temp1.cap = 0; + arg1 = (coin__UxArray *)&temp1; } { - if (!PyCallable_Check(obj1)) SWIG_fail; - temp2.callback = _WrapperFeeCalculator; - temp2.context = obj1; arg2 = &temp2; } - result = (GoUint32)SKY_coin_Transactions_Fees(arg1,arg2,arg3); + if (!PyArg_ParseTuple(args,(char *)":SKY_coin_NewAddressUxOuts")) SWIG_fail; + result = (GoUint32)SKY_coin_NewAddressUxOuts(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); + free( (void*)arg1->data ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -19432,44 +19381,43 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Fees(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - GoInt arg2 ; - Transaction__Handle *arg3 = (Transaction__Handle *) 0 ; - long long val2 ; - int ecode2 = 0 ; - Handle temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_NewAddressUxOuts(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; - { - arg3 = &temp3; + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_GetAt",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (argc == 0) { + return _wrap_SKY_coin_NewAddressUxOuts__SWIG_1(self, args); } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_GetAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_coin_Transactions_GetAt(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + if (argc == 1) { + int _v; + { + _v = PyList_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_NewAddressUxOuts__SWIG_0(self, args); + } } - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_NewAddressUxOuts'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_NewAddressUxOuts(coin_UxOutArray *,AddressUxOuts_Handle *)\n" + " SKY_coin_NewAddressUxOuts(coin__UxArray *,AddressUxOuts_Handle *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle arg1 ; + AddressUxOuts_Handle arg1 ; coin__UxArray *arg2 = (coin__UxArray *) 0 ; GoSlice_ temp2 ; PyObject * obj0 = 0 ; @@ -19481,11 +19429,11 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUN temp2.cap = 0; arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Hashes",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Keys",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_Transactions_Hashes(arg1,arg2); + result = (GoUint32)SKY_coin_AddressUxOuts_Keys(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); @@ -19497,7 +19445,7 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Keys(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 @@ -19515,7 +19463,7 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject _v = PyInt_Check(argv[0]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_Transactions_Hashes__SWIG_0(self, args); + return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_0(self, args); } } if (argc == 1) { @@ -19524,110 +19472,42 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Hashes(PyObject *self, PyObject _v = PyInt_Check(argv[0]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_Transactions_Hashes__SWIG_1(self, args); + return _wrap_SKY_coin_AddressUxOuts_Keys__SWIG_1(self, args); } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_Transactions_Hashes'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Keys'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_Transactions_Hashes(Transactions__Handle,cipher_SHA256s *)\n" - " SKY_coin_Transactions_Hashes(Transactions__Handle,coin__UxArray *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - GoUint32 result; - - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Transactions_Size",&obj0)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - result = (GoUint32)SKY_coin_Transactions_Size(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Transactions_TruncateBytesTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - GoUint32 arg2 ; - Transactions__Handle *arg3 = (Transactions__Handle *) 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - Handle temp3 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - GoUint32 result; - - { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_Transactions_TruncateBytesTo",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_Transactions_TruncateBytesTo" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - result = (GoUint32)SKY_coin_Transactions_TruncateBytesTo(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); - } - return resultobj; -fail: - return NULL; + " wrap_SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,cipher_Addresses *)\n" + " SKY_coin_AddressUxOuts_Keys(AddressUxOuts_Handle,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Transactions__Handle arg1 ; - FeeCalculator *arg2 = (FeeCalculator *) 0 ; - Transactions__Handle *arg3 = (Transactions__Handle *) 0 ; - FeeCalculator temp2 ; - Handle temp3 ; + AddressUxOuts_Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_SortTransactions",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Flatten",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - if (!PyCallable_Check(obj1)) SWIG_fail; - temp2.callback = _WrapperFeeCalculator; - temp2.context = obj1; - arg2 = &temp2; - } - result = (GoUint32)SKY_coin_SortTransactions(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_AddressUxOuts_Flatten(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); } return resultobj; fail: @@ -19635,101 +19515,70 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortTransactions(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_coin_NewSortableTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - Transactions__Handle arg1 ; - FeeCalculator *arg2 = (FeeCalculator *) 0 ; - SortableTransactionResult_Handle *arg3 = (SortableTransactionResult_Handle *) 0 ; - FeeCalculator temp2 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Flatten(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + Py_ssize_t ii; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_NewSortableTransactions",&obj0,&obj1,&obj2)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + if (!PyTuple_Check(args)) SWIG_fail; + argc = args ? PyObject_Length(args) : 0; + for (ii = 0; (ii < 1) && (ii < argc); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); } - { - if (!PyCallable_Check(obj1)) SWIG_fail; - temp2.callback = _WrapperFeeCalculator; - temp2.context = obj1; - arg2 = &temp2; + if (argc == 1) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_0(self, args); + } } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_SortableTransactionResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_coin_NewSortableTransactions" "', argument " "3"" of type '" "SortableTransactionResult_Handle *""'"); + if (argc == 1) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + return _wrap_SKY_coin_AddressUxOuts_Flatten__SWIG_1(self, args); + } } - arg3 = (SortableTransactionResult_Handle *)(argp3); - result = (GoUint32)SKY_coin_NewSortableTransactions(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; + fail: - return NULL; + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Flatten'.\n" + " Possible C/C++ prototypes are:\n" + " wrap_SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin_UxOutArray *)\n" + " SKY_coin_AddressUxOuts_Flatten(AddressUxOuts_Handle,coin__UxArray *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Sub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - SortableTransactionResult_Handle arg1 ; - void *argp1 ; - int res1 = 0 ; + AddressUxOuts_Handle arg1 ; + AddressUxOuts_Handle arg2 ; + AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Sort",&obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Sort" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } else { - arg1 = *((SortableTransactionResult_Handle *)(argp1)); - } + arg3 = &temp3; } - result = (GoUint32)SKY_coin_SortableTransactions_Sort(arg1); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SortableTransactionResult_Handle arg1 ; - GoInt *arg2 = (GoInt *) 0 ; - void *argp1 ; - int res1 = 0 ; - GoInt temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - GoUint32 result; - - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_SortableTransactions_Len",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Sub",&obj0,&obj1)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Len" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } else { - arg1 = *((SortableTransactionResult_Handle *)(argp1)); - } + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_coin_SortableTransactions_Len(arg1,arg2); + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } + result = (GoUint32)SKY_coin_AddressUxOuts_Sub(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -19737,138 +19586,69 @@ SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Len(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Less(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - SortableTransactionResult_Handle arg1 ; - GoInt arg2 ; - GoInt arg3 ; - GoUint8 *arg4 = (GoUint8 *) 0 ; - void *argp1 ; - int res1 = 0 ; - long long val2 ; - int ecode2 = 0 ; - long long val3 ; - int ecode3 = 0 ; - GoUint8 temp4 ; - int res4 = SWIG_TMPOBJ ; + AddressUxOuts_Handle arg1 ; + AddressUxOuts_Handle arg2 ; + AddressUxOuts_Handle *arg3 = (AddressUxOuts_Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - arg4 = &temp4; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Less",&obj0,&obj1,&obj2)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } else { - arg1 = *((SortableTransactionResult_Handle *)(argp1)); - } + arg3 = &temp3; } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Less" "', argument " "3"" of type '" "GoInt""'"); - } - arg3 = (GoInt)(val3); - result = (GoUint32)SKY_coin_SortableTransactions_Less(arg1,arg2,arg3,arg4); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res4)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4))); - } else { - int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags)); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Add",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_SortableTransactions_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - SortableTransactionResult_Handle arg1 ; - GoInt arg2 ; - GoInt arg3 ; - void *argp1 ; - int res1 = 0 ; - long long val2 ; - int ecode2 = 0 ; - long long val3 ; - int ecode3 = 0 ; - PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - GoUint32 result; - - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_coin_SortableTransactions_Swap",&obj0,&obj1,&obj2)) SWIG_fail; { - res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_SortableTransactionResult_Handle, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "1"" of type '" "SortableTransactionResult_Handle""'"); - } else { - arg1 = *((SortableTransactionResult_Handle *)(argp1)); - } + SWIG_AsVal_long(obj1, (long*)&arg2); } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_coin_SortableTransactions_Swap" "', argument " "3"" of type '" "GoInt""'"); - } - arg3 = (GoInt)(val3); - result = (GoUint32)SKY_coin_SortableTransactions_Swap(arg1,arg2,arg3); + result = (GoUint32)SKY_coin_AddressUxOuts_Add(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - coin__UxArray *arg1 = (coin__UxArray *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp1 ; - GoSlice_ temp2 ; + AddressUxOuts_Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + GoSlice_ temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp1.data = NULL; - temp1.len = 0; - temp1.cap = 0; - arg1 = (coin__UxArray *)&temp1; + temp3.data = NULL; + temp3.len = 0; + temp3.cap = 0; + arg3 = (coin__UxArray *)&temp3; } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Get",&obj0,&obj1)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)":SKY_coin_VerifyTransactionCoinsSpending")) SWIG_fail; - result = (GoUint32)SKY_coin_VerifyTransactionCoinsSpending(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->data, arg1->len )); - free( (void*)arg1->data ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Get" "', argument " "2"" of type '" "cipher__Address *""'"); } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_coin_AddressUxOuts_Get(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); + free( (void*)arg3->data ); } return resultobj; fail: @@ -19876,7 +19656,7 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Get(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 @@ -19888,69 +19668,175 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionCoinsSpending(PyObject *sel for (ii = 0; (ii < 2) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 0) { - return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_1(self, args); - } if (argc == 2) { int _v; { - _v = PyList_Check(argv[0]) ? 1 : 0; + _v = PyInt_Check(argv[0]) ? 1 : 0; } if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_0(self, args); } + } + } + if (argc == 2) { + int _v; + { + _v = PyInt_Check(argv[0]) ? 1 : 0; + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_SKY_coin_VerifyTransactionCoinsSpending__SWIG_0(self, args); + return _wrap_SKY_coin_AddressUxOuts_Get__SWIG_1(self, args); } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionCoinsSpending'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Get'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_VerifyTransactionCoinsSpending(coin_UxOutArray *,coin_UxOutArray *)\n" - " SKY_coin_VerifyTransactionCoinsSpending(coin__UxArray *,coin__UxArray *)\n"); + " wrap_SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n" + " SKY_coin_AddressUxOuts_Get(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_HasKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - GoSlice_ temp2 ; - GoSlice_ temp3 ; + AddressUxOuts_Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + GoUint8 *arg3 = (GoUint8 *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + GoUint8 temp3 ; + int res3 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_HasKey",&obj0,&obj1)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); + } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_HasKey" "', argument " "2"" of type '" "cipher__Address *""'"); + } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_coin_AddressUxOuts_HasKey(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res3)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); + } else { + int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_GetOutputLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + AddressUxOuts_Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + GoInt *arg3 = (GoInt *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + GoInt temp3 ; + int res3 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + arg3 = &temp3; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_GetOutputLength",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_GetOutputLength" "', argument " "2"" of type '" "cipher__Address *""'"); + } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_coin_AddressUxOuts_GetOutputLength(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res3)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); + } else { + int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long_long, new_flags)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + AddressUxOuts_Handle arg1 ; + GoInt *arg2 = (GoInt *) 0 ; + GoInt temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + GoUint32 result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_AddressUxOuts_Length",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_coin_AddressUxOuts_Length(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long_long, new_flags)); } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + AddressUxOuts_Handle arg1 ; + cipher__Address *arg2 = (cipher__Address *) 0 ; + coin__UxArray *arg3 = (coin__UxArray *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + GoSlice_ temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + { temp3.data = NULL; temp3.len = 0; temp3.cap = 0; arg3 = (coin__UxArray *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_VerifyTransactionHoursSpending",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_VerifyTransactionHoursSpending" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - result = (GoUint32)SKY_coin_VerifyTransactionHoursSpending(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddressUxOuts_Set",&obj0,&obj1)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + SWIG_AsVal_long(obj0, (long*)&arg1); + } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_coin_AddressUxOuts_Set" "', argument " "2"" of type '" "cipher__Address *""'"); } + arg2 = (cipher__Address *)(argp2); + result = (GoUint32)SKY_coin_AddressUxOuts_Set(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); free( (void*)arg3->data ); @@ -19961,7 +19847,7 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_coin_AddressUxOuts_Set(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 @@ -19973,113 +19859,104 @@ SWIGINTERN PyObject *_wrap_SKY_coin_VerifyTransactionHoursSpending(PyObject *sel for (ii = 0; (ii < 3) && (ii < argc); ii++) { argv[ii] = PyTuple_GET_ITEM(args,ii); } - if (argc == 1) { + if (argc == 2) { int _v; { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); - _v = SWIG_CheckState(res); + _v = PyInt_Check(argv[0]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_1(self, args); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_1(self, args); + } } } if (argc == 3) { int _v; { - int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL); - _v = SWIG_CheckState(res); + _v = PyInt_Check(argv[0]) ? 1 : 0; } if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_cipher__Address, 0); + _v = SWIG_CheckState(res); if (_v) { { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_SKY_coin_VerifyTransactionHoursSpending__SWIG_0(self, args); + return _wrap_SKY_coin_AddressUxOuts_Set__SWIG_0(self, args); } } } } fail: - SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_VerifyTransactionHoursSpending'.\n" + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SKY_coin_AddressUxOuts_Set'.\n" " Possible C/C++ prototypes are:\n" - " wrap_SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin_UxOutArray *,coin_UxOutArray *)\n" - " SKY_coin_VerifyTransactionHoursSpending(GoUint64,coin__UxArray *,coin__UxArray *)\n"); + " wrap_SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin_UxOutArray *)\n" + " SKY_coin_AddressUxOuts_Set(AddressUxOuts_Handle,cipher__Address *,coin__UxArray *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SKY_cli_GenerateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoString arg1 ; - Options__Handle *arg2 = (Options__Handle *) 0 ; - GoUint64 arg3 ; - Wallet__Handle *arg4 = (Wallet__Handle *) 0 ; + Client__Handle *arg2 = (Client__Handle *) 0 ; Handle temp2 ; - unsigned long long val3 ; - int ecode3 = 0 ; - Handle temp4 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { arg2 = &temp2; } - { - arg4 = &temp4; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GenerateWallet",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewClient",&obj0)) SWIG_fail; { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GenerateWallet', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_NewClient', expecting string"); } (&arg1)->p = buffer; (&arg1)->n = size - 1; } - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_cli_GenerateWallet" "', argument " "3"" of type '" "GoUint64""'"); - } - arg3 = (GoUint64)(val3); - result = (GoUint32)SKY_cli_GenerateWallet(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_api_NewClient(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_MakeAlphanumericSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString_ *arg1 = (GoString_ *) 0 ; - GoString temp1 ; + Client__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; GoUint32 result; { - temp1.p = NULL; - temp1.n = 0; - arg1 = (GoString_ *)&temp1; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)":SKY_cli_MakeAlphanumericSeed")) SWIG_fail; - result = (GoUint32)SKY_cli_MakeAlphanumericSeed(arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CSRF",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Client_CSRF(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); - free( (void*)arg1->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -20087,70 +19964,48 @@ SWIGINTERN PyObject *_wrap_SKY_cli_MakeAlphanumericSeed(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputsFromFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString arg2 ; - ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetWalletOutputsFromFile",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Version",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetWalletOutputsFromFile', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputsFromFile" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3); - result = (GoUint32)SKY_cli_GetWalletOutputsFromFile(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_Version(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Outputs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - Wallet__Handle *arg2 = (Wallet__Handle *) 0 ; - ReadableUnspentOutputsSummary_Handle *arg3 = (ReadableUnspentOutputsSummary_Handle *) 0 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; Handle temp2 ; - void *argp3 = 0 ; - int res3 = 0 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_GetWalletOutputs",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Outputs",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - res3 = SWIG_ConvertPtr(obj1, &argp3,SWIGTYPE_p_ReadableUnspentOutputsSummary_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetWalletOutputs" "', argument " "3"" of type '" "ReadableUnspentOutputsSummary_Handle *""'"); - } - arg3 = (ReadableUnspentOutputsSummary_Handle *)(argp3); - result = (GoUint32)SKY_cli_GetWalletOutputs(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_Outputs(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); @@ -20161,19 +20016,20 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GetWalletOutputs(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_cli_CheckWalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString arg2 ; - BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Client__Handle arg1 ; + GoSlice arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_CheckWalletBalance",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForAddresses",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -20182,37 +20038,37 @@ SWIGINTERN PyObject *_wrap_SKY_cli_CheckWalletBalance(PyObject *SWIGUNUSEDPARM(s size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CheckWalletBalance', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForAddresses', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_CheckWalletBalance" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - arg3 = (BalanceResult_Handle *)(argp3); - result = (GoUint32)SKY_cli_CheckWalletBalance(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_OutputsForAddresses(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_OutputsForHashes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; + Client__Handle arg1 ; GoSlice arg2 ; - BalanceResult_Handle *arg3 = (BalanceResult_Handle *) 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_GetBalanceOfAddresses",&obj0,&obj1,&obj2)) SWIG_fail; + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_OutputsForHashes",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -20221,34 +20077,63 @@ SWIGINTERN PyObject *_wrap_SKY_cli_GetBalanceOfAddresses(PyObject *SWIGUNUSEDPAR size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_GetBalanceOfAddresses', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_OutputsForHashes', expecting string"); } (&arg2)->data = buffer; (&arg2)->len = size - 1; (&arg2)->cap = size; } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_BalanceResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_cli_GetBalanceOfAddresses" "', argument " "3"" of type '" "BalanceResult_Handle *""'"); + result = (GoUint32)SKY_api_Client_OutputsForHashes(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } - arg3 = (BalanceResult_Handle *)(argp3); - result = (GoUint32)SKY_cli_GetBalanceOfAddresses(arg1,arg2,arg3); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Client_CoinSupply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CoinSupply",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Client_CoinSupply(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockByHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - App__Handle arg1 ; + Client__Handle arg1 ; GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_App_Run",&obj0,&obj1)) SWIG_fail; + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockByHash",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } @@ -20257,41 +20142,89 @@ SWIGINTERN PyObject *_wrap_SKY_cli_App_Run(PyObject *SWIGUNUSEDPARM(self), PyObj size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_App_Run', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_BlockByHash', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; } - result = (GoUint32)SKY_cli_App_Run(arg1,arg2); + result = (GoUint32)SKY_api_Client_BlockByHash(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetCoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Config__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + GoUint64 arg2 ; + Handle *arg3 = (Handle *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetCoin",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_BlockBySeq",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_BlockBySeq" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_api_Client_BlockBySeq(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Client_Blocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Client__Handle arg1 ; + GoSlice arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Blocks",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_Config_GetCoin(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Blocks', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; + } + result = (GoUint32)SKY_api_Client_Blocks(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20299,28 +20232,34 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetCoin(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_LastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Config__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + GoUint64 arg2 ; + Handle *arg3 = (Handle *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Config_GetRPCAddress",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_LastBlocks",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_Config_GetRPCAddress(arg1,arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_LastBlocks" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_api_Client_LastBlocks(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20328,10 +20267,10 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Config_GetRPCAddress(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainMetadata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - App__Handle arg1 ; - WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -20339,11 +20278,11 @@ SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(sel { arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_RPCClientFromApp",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainMetadata",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_RPCClientFromApp(arg1,arg2); + result = (GoUint32)SKY_api_Client_BlockchainMetadata(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); @@ -20354,35 +20293,25 @@ SWIGINTERN PyObject *_wrap_SKY_cli_RPCClientFromApp(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_cli_Getenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_BlockchainProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cli_Getenv",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_BlockchainProgress",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Getenv', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_Getenv(arg1,arg2); + result = (GoUint32)SKY_api_Client_BlockchainProgress(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -20390,36 +20319,39 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Getenv(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Balance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString arg2 ; + Client__Handle arg1 ; + GoSlice arg2 ; + wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cli_Setenv",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_Balance",&obj0,&obj1,&obj2)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_Setenv', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Balance', expecting string"); } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_cli_Setenv(arg1,arg2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_Balance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); + } + arg3 = (wallet__BalancePair *)(argp3); + result = (GoUint32)SKY_api_Client_Balance(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -20427,70 +20359,37 @@ SWIGINTERN PyObject *_wrap_SKY_cli_Setenv(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SKY_coin_AddUint64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_UxOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoUint64 arg1 ; - GoUint64 arg2 ; - GoUint64 *arg3 = (GoUint64 *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - GoUint64 temp3 ; + Client__Handle arg1 ; + GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; { - temp3 = 0; arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_coin_AddUint64",&obj0,&obj1)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_AddUint64" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_coin_AddUint64" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_coin_AddUint64(arg1,arg2,arg3); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UxOut",&obj0,&obj1)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg3 )); + SWIG_AsVal_long(obj0, (long*)&arg1); } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_Uint64ToInt64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoUint64 arg1 ; - GoInt64 *arg2 = (GoInt64 *) 0 ; - unsigned long long val1 ; - int ecode1 = 0 ; - GoInt64 temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; - { - temp2 = 0; - arg2 = &temp2; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UxOut', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Uint64ToInt64",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_Uint64ToInt64" "', argument " "1"" of type '" "GoUint64""'"); - } - arg1 = (GoUint64)(val1); - result = (GoUint32)SKY_coin_Uint64ToInt64(arg1,arg2); + result = (GoUint32)SKY_api_Client_UxOut(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20498,86 +20397,37 @@ SWIGINTERN PyObject *_wrap_SKY_coin_Uint64ToInt64(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_coin_Int64ToUint64(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoInt64 arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - long long val1 ; - int ecode1 = 0 ; - GoUint64 temp2 ; + Client__Handle arg1 ; + GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_Int64ToUint64",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_Int64ToUint64" "', argument " "1"" of type '" "GoInt64""'"); - } - arg1 = (GoInt64)(val1); - result = (GoUint32)SKY_coin_Int64ToUint64(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressUxOuts",&obj0,&obj1)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_coin_IntToUint32(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoInt arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - long long val1 ; - int ecode1 = 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; - PyObject * obj0 = 0 ; - GoUint32 result; - - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_coin_IntToUint32",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_coin_IntToUint32" "', argument " "1"" of type '" "GoInt""'"); - } - arg1 = (GoInt)(val1); - result = (GoUint32)SKY_coin_IntToUint32(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); + SWIG_AsVal_long(obj0, (long*)&arg1); } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoString_ *arg1 = (GoString_ *) 0 ; - GoString temp1 ; - GoUint32 result; - { - temp1.p = NULL; - temp1.n = 0; - arg1 = (GoString_ *)&temp1; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressUxOuts', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)":SKY_iputil_LocalhostIP")) SWIG_fail; - result = (GoUint32)SKY_iputil_LocalhostIP(arg1); + result = (GoUint32)SKY_api_Client_AddressUxOuts(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); - free( (void*)arg1->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20585,34 +20435,37 @@ SWIGINTERN PyObject *_wrap_SKY_iputil_LocalhostIP(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_iputil_IsLocalhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + Client__Handle arg1 ; + GoString arg2 ; + WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_IsLocalhost",&obj0)) SWIG_fail; + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Wallet",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_IsLocalhost', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Wallet', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - result = (GoUint32)SKY_iputil_IsLocalhost(arg1,arg2); + result = (GoUint32)SKY_api_Client_Wallet(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20620,45 +20473,25 @@ SWIGINTERN PyObject *_wrap_SKY_iputil_IsLocalhost(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_iputil_SplitAddr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Wallets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoUint16 *arg3 = (GoUint16 *) 0 ; - GoString temp2 ; - GoUint16 temp3 ; - int res3 = SWIG_TMPOBJ ; + Client__Handle arg1 ; + Wallets__Handle *arg2 = (Wallets__Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - arg3 = &temp3; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_iputil_SplitAddr",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Wallets",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_iputil_SplitAddr', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_iputil_SplitAddr(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_Wallets(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); - } - if (SWIG_IsTmpObj(res3)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3))); - } else { - int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_short, new_flags)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -20666,49 +20499,35 @@ SWIGINTERN PyObject *_wrap_SKY_iputil_SplitAddr(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateUnencryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; + Client__Handle arg1 ; GoString arg2 ; - GoSlice arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - coin__UxArray *arg5 = (coin__UxArray *) 0 ; - GoSlice_ temp4 ; - GoSlice_ temp5 ; + GoString arg3 ; + GoInt arg4 ; + WalletResponse__Handle *arg5 = (WalletResponse__Handle *) 0 ; + long long val4 ; + int ecode4 = 0 ; + Handle temp5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; GoUint32 result; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; - } - { - temp5.data = NULL; - temp5.len = 0; - temp5.cap = 0; - arg5 = (coin__UxArray *)&temp5; + arg5 = &temp5; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_certutil_NewTLSCertPair",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_CreateUnencryptedWallet",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } { char* buffer = 0; size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string"); } (&arg2)->p = buffer; (&arg2)->n = size - 1; @@ -20718,21 +20537,20 @@ SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM( size_t size = 0; int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_certutil_NewTLSCertPair', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateUnencryptedWallet', expecting string"); } - (&arg3)->data = buffer; - (&arg3)->len = size - 1; - (&arg3)->cap = size; + (&arg3)->p = buffer; + (&arg3)->n = size - 1; } - result = (GoUint32)SKY_certutil_NewTLSCertPair(arg1,arg2,arg3,arg4,arg5); + ecode4 = SWIG_AsVal_long_SS_long(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_CreateUnencryptedWallet" "', argument " "4"" of type '" "GoInt""'"); + } + arg4 = (GoInt)(val4); + result = (GoUint32)SKY_api_Client_CreateUnencryptedWallet(arg1,arg2,arg3,arg4,arg5); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg5->data, arg5->len )); - free( (void*)arg5->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5)); } return resultobj; fail: @@ -20740,100 +20558,168 @@ SWIGINTERN PyObject *_wrap_SKY_certutil_NewTLSCertPair(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_cipher_DecodeBase58Address(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateEncryptedWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; + GoString arg4 ; + GoInt arg5 ; + WalletResponse__Handle *arg6 = (WalletResponse__Handle *) 0 ; + long long val5 ; + int ecode5 = 0 ; + Handle temp6 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DecodeBase58Address",&obj0,&obj1)) SWIG_fail; + { + arg6 = &temp6; + } + if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_api_Client_CreateEncryptedWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DecodeBase58Address', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_DecodeBase58Address" "', argument " "2"" of type '" "cipher__Address *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_cipher_DecodeBase58Address(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_CreateEncryptedWallet', expecting string"); + } + (&arg4)->p = buffer; + (&arg4)->n = size - 1; + } + ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SKY_api_Client_CreateEncryptedWallet" "', argument " "5"" of type '" "GoInt""'"); + } + arg5 = (GoInt)(val5); + result = (GoUint32)SKY_api_Client_CreateEncryptedWallet(arg1,arg2,arg3,arg4,arg5,arg6); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NewWalletAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + GoInt arg3 ; + GoString arg4 ; + Strings__Handle *arg5 = (Strings__Handle *) 0 ; + long long val3 ; + int ecode3 = 0 ; + Handle temp5 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromBytes",&obj0,&obj1)) SWIG_fail; + { + arg5 = &temp5; + } + if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Client_NewWalletAddress",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_AddressFromBytes', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string"); } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromBytes" "', argument " "2"" of type '" "cipher__Address *""'"); + ecode3 = SWIG_AsVal_long_SS_long(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_api_Client_NewWalletAddress" "', argument " "3"" of type '" "GoInt""'"); + } + arg3 = (GoInt)(val3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NewWalletAddress', expecting string"); + } + (&arg4)->p = buffer; + (&arg4)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_cipher_AddressFromBytes(arg1,arg2); + result = (GoUint32)SKY_api_Client_NewWalletAddress(arg1,arg2,arg3,arg4,arg5); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg5)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromPubKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__PubKey *arg1 = (cipher__PubKey *) 0 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + wallet__BalancePair *arg3 = (wallet__BalancePair *) 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromPubKey",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletBalance",&obj0,&obj1,&obj2)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg1 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromPubKey" "', argument " "2"" of type '" "cipher__Address *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletBalance', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_cipher_AddressFromPubKey((unsigned char (*)[33])arg1,arg2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wallet__BalancePair, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Client_WalletBalance" "', argument " "3"" of type '" "wallet__BalancePair *""'"); + } + arg3 = (wallet__BalancePair *)(argp3); + result = (GoUint32)SKY_api_Client_WalletBalance(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -20841,31 +20727,71 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromPubKey(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromSecKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Spend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__SecKey *arg1 = (cipher__SecKey *) 0 ; - cipher__Address *arg2 = (cipher__Address *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; + GoUint64 arg4 ; + GoString arg5 ; + SpendResult_Handle *arg6 = (SpendResult_Handle *) 0 ; + unsigned long long val4 ; + int ecode4 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_AddressFromSecKey",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_api_Client_Spend",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SecKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type SecKey"); - cipher_SecKey* p = (cipher_SecKey*)argp; - arg1 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_cipher_AddressFromSecKey" "', argument " "2"" of type '" "cipher__Address *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - arg2 = (cipher__Address *)(argp2); - result = (GoUint32)SKY_cipher_AddressFromSecKey((unsigned char (*)[32])arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SKY_api_Client_Spend" "', argument " "4"" of type '" "GoUint64""'"); + } + arg4 = (GoUint64)(val4); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Spend', expecting string"); + } + (&arg5)->p = buffer; + (&arg5)->n = size - 1; + } + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_SpendResult_Handle, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_api_Client_Spend" "', argument " "6"" of type '" "SpendResult_Handle *""'"); + } + arg6 = (SpendResult_Handle *)(argp6); + result = (GoUint32)SKY_api_Client_Spend(arg1,arg2,arg3,arg4,arg5,arg6); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -20873,31 +20799,33 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_AddressFromSecKey(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_CreateTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + CreateTransactionResponse__Handle *arg3 = (CreateTransactionResponse__Handle *) 0 ; + Handle temp2 ; + Handle temp3 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Null",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Null" "', argument " "1"" of type '" "cipher__Address *""'"); + { + arg2 = &temp2; } - arg1 = (cipher__Address *)(argp1); - result = (GoUint32)SKY_cipher_Address_Null(arg1,arg2); + { + arg3 = &temp3; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_CreateTransaction",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Client_CreateTransaction(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -20905,98 +20833,105 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Null(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Bytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_UpdateWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoSlice_ temp2 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_UpdateWallet",&obj0,&obj1,&obj2)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + SWIG_AsVal_long(obj0, (long*)&arg1); } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_Bytes",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Bytes" "', argument " "1"" of type '" "cipher__Address *""'"); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - arg1 = (cipher__Address *)(argp1); - result = (GoUint32)SKY_cipher_Address_Bytes(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UpdateWallet', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; } + result = (GoUint32)SKY_api_Client_UpdateWallet(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletFolderName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - cipher__PubKey *arg2 = (cipher__PubKey *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Verify",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Verify" "', argument " "1"" of type '" "cipher__Address *""'"); + { + arg2 = &temp2; } - arg1 = (cipher__Address *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_WalletFolderName",&obj0)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cipher_Address_Verify(arg1,(unsigned char (*)[33])arg2); + result = (GoUint32)SKY_api_Client_WalletFolderName(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NewSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - GoString_ *arg2 = (GoString_ *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - GoString temp2 ; + Client__Handle arg1 ; + GoInt arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + long long val2 ; + int ecode2 = 0 ; + GoString temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_Address_String",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_String" "', argument " "1"" of type '" "cipher__Address *""'"); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NewSeed",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg1 = (cipher__Address *)(argp1); - result = (GoUint32)SKY_cipher_Address_String(arg1,arg2); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Client_NewSeed" "', argument " "2"" of type '" "GoInt""'"); + } + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_api_Client_NewSeed(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -21004,45 +20939,64 @@ SWIGINTERN PyObject *_wrap_SKY_cipher_Address_String(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_cipher_Address_Checksum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_WalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - cipher__Checksum *arg2 = (cipher__Checksum *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; + GoString_ *arg4 = (GoString_ *) 0 ; + GoString temp4 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Address_Checksum",&obj0,&obj1)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Address_Checksum" "', argument " "1"" of type '" "cipher__Address *""'"); + { + temp4.p = NULL; + temp4.n = 0; + arg4 = (GoString_ *)&temp4; } - arg1 = (cipher__Address *)(argp1); + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_WalletSeed",&obj0,&obj1,&obj2)) SWIG_fail; { - void *argp = 0; - int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Checksum, 0 | 0); - if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type Checksum"); - cipher_Checksum* p = (cipher_Checksum*)argp; - arg2 = &p->data; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cipher_Address_Checksum(arg1,(unsigned char (*)[4])arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_WalletSeed', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_WalletSeed(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); + free( (void*)arg4->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - wallet__Entry *arg2 = (wallet__Entry *) 0 ; - ReadableEntry__Handle *arg3 = (ReadableEntry__Handle *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; @@ -21051,23 +21005,21 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM( { arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_NewReadableEntry",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnection",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } { char* buffer = 0; size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_NewReadableEntry', expecting string"); + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_NetworkConnection', expecting string"); } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; - } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wallet__Entry, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_wallet_NewReadableEntry" "', argument " "2"" of type '" "wallet__Entry *""'"); + (&arg2)->p = buffer; + (&arg2)->n = size - 1; } - arg2 = (wallet__Entry *)(argp2); - result = (GoUint32)SKY_wallet_NewReadableEntry(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_NetworkConnection(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); @@ -21078,32 +21030,34 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_NewReadableEntry(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - ReadableWallet__Handle *arg2 = (ReadableWallet__Handle *) 0 ; - Handle temp2 ; + Client__Handle arg1 ; + api__NetworkConnectionsFilter *arg2 = (api__NetworkConnectionsFilter *) 0 ; + Handle *arg3 = (Handle *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_LoadReadableWallet",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_NetworkConnections",&obj0,&obj1)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_LoadReadableWallet', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_LoadReadableWallet(arg1,arg2); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__NetworkConnectionsFilter, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_NetworkConnections" "', argument " "2"" of type '" "api__NetworkConnectionsFilter *""'"); + } + arg2 = (api__NetworkConnectionsFilter *)(argp2); + result = (GoUint32)SKY_api_Client_NetworkConnections(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21111,150 +21065,192 @@ SWIGINTERN PyObject *_wrap_SKY_wallet_LoadReadableWallet(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkDefaultPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - ReadableWallet__Handle arg1 ; - GoString arg2 ; + Client__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Save",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkDefaultPeers",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Save', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_ReadableWallet_Save(arg1,arg2); + result = (GoUint32)SKY_api_Client_NetworkDefaultPeers(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkTrustedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - ReadableWallet__Handle arg1 ; - GoString arg2 ; + Client__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_wallet_ReadableWallet_Load",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkTrustedPeers",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_wallet_ReadableWallet_Load', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_ReadableWallet_Load(arg1,arg2); + result = (GoUint32)SKY_api_Client_NetworkTrustedPeers(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_ReadableWallet_Erase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_NetworkExchangedPeers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - ReadableWallet__Handle arg1 ; + Client__Handle arg1 ; + coin__UxArray *arg2 = (coin__UxArray *) 0 ; + GoSlice_ temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_ReadableWallet_Erase",&obj0)) SWIG_fail; + { + temp2.data = NULL; + temp2.len = 0; + temp2.cap = 0; + arg2 = (coin__UxArray *)&temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_NetworkExchangedPeers",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_wallet_ReadableWallet_Erase(arg1); + result = (GoUint32)SKY_api_Client_NetworkExchangedPeers(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); + free( (void*)arg2->data ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_Verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_PendingTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__Entry *arg1 = (wallet__Entry *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_Verify",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_Verify" "', argument " "1"" of type '" "wallet__Entry *""'"); + { + arg2 = &temp2; } - arg1 = (wallet__Entry *)(argp1); - result = (GoUint32)SKY_wallet_Entry_Verify(arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_PendingTransactions",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Client_PendingTransactions(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_wallet_Entry_VerifyPublic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - wallet__Entry *arg1 = (wallet__Entry *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + Client__Handle arg1 ; + GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_wallet_Entry_VerifyPublic",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wallet__Entry, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_wallet_Entry_VerifyPublic" "', argument " "1"" of type '" "wallet__Entry *""'"); + { + arg3 = &temp3; } - arg1 = (wallet__Entry *)(argp1); - result = (GoUint32)SKY_wallet_Entry_VerifyPublic(arg1); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transaction",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transaction', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_Transaction(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Transactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + GoSlice arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_JsonEncode_Handle",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Transactions",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_JsonEncode_Handle(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_Transactions', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; + } + result = (GoUint32)SKY_api_Client_Transactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21262,26 +21258,38 @@ SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_ConfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + Client__Handle arg1 ; + GoSlice arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Progress_GetCurrent",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_ConfirmedTransactions",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Progress_GetCurrent(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_ConfirmedTransactions', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; + } + result = (GoUint32)SKY_api_Client_ConfirmedTransactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21289,26 +21297,38 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_UnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + Client__Handle arg1 ; + GoSlice arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadSeq",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnconfirmedTransactions",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Block_GetHeadSeq(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnconfirmedTransactions', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; + } + result = (GoUint32)SKY_api_Client_UnconfirmedTransactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21316,28 +21336,33 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadSeq(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + Transaction__Handle arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadHash",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Block_GetHeadHash(arg1,arg2); + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } + result = (GoUint32)SKY_api_Client_InjectTransaction(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -21345,28 +21370,25 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadHash(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_ResendUnconfirmedTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetPreviousBlockHash",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_ResendUnconfirmedTransactions",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Block_GetPreviousBlockHash(arg1,arg2); + result = (GoUint32)SKY_api_Client_ResendUnconfirmedTransactions(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -21374,34 +21396,40 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_RawTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoUint64 arg2 ; - Handle *arg3 = (Handle *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - Handle temp3 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; { - arg3 = &temp3; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Blocks_GetAt",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_RawTransaction",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Blocks_GetAt" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_Handle_Blocks_GetAt(arg1,arg2,arg3); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_RawTransaction', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_RawTransaction(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -21409,26 +21437,37 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetAt(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressTransactions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + Client__Handle arg1 ; + GoString arg2 ; + Handle *arg3 = (Handle *) 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Blocks_GetCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_AddressTransactions",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Blocks_GetCount(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_AddressTransactions', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_AddressTransactions(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21436,26 +21475,34 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetCount(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Richlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Handle arg1 ; - GoUint64 *arg2 = (GoUint64 *) 0 ; - GoUint64 temp2 ; + Client__Handle arg1 ; + api__RichlistParams *arg2 = (api__RichlistParams *) 0 ; + Handle *arg3 = (Handle *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2 = 0; - arg2 = &temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Connections_GetCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_Richlist",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Connections_GetCount(arg1,arg2); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_api__RichlistParams, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_api_Client_Richlist" "', argument " "2"" of type '" "api__RichlistParams *""'"); + } + arg2 = (api__RichlistParams *)(argp2); + result = (GoUint32)SKY_api_Client_Richlist(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -21463,27 +21510,26 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_AddressCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Strings__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; + Client__Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_GetCount",&obj0)) SWIG_fail; + { + temp2 = 0; + arg2 = &temp2; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_AddressCount",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Strings_GetCount(arg1,arg2); + result = (GoUint32)SKY_api_Client_AddressCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -21491,17 +21537,29 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetCount(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_UnloadWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Strings__Handle arg1 ; + Client__Handle arg1 ; + GoString arg2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_Sort",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Client_UnloadWallet",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_Handle_Strings_Sort(arg1); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_UnloadWallet', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_UnloadWallet(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -21509,37 +21567,25 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_Sort(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_Health(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Strings__Handle arg1 ; - GoInt arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - long long val2 ; - int ecode2 = 0 ; - GoString temp3 ; + Client__Handle arg1 ; + Handle *arg2 = (Handle *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Strings_GetAt",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Client_Health",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Strings_GetAt" "', argument " "2"" of type '" "GoInt""'"); - } - arg2 = (GoInt)(val2); - result = (GoUint32)SKY_Handle_Strings_GetAt(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Client_Health(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -21547,28 +21593,49 @@ SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_EncryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Client__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + GoString arg2 ; + GoString arg3 ; + WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ; + Handle temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg4 = &temp4; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletDir",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_EncryptWallet",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_Client_GetWalletDir(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_EncryptWallet', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_EncryptWallet(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); } return resultobj; fail: @@ -21576,28 +21643,49 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Client_DecryptWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Client__Handle arg1 ; + GoString arg2 ; + GoString arg3 ; + WalletResponse__Handle *arg4 = (WalletResponse__Handle *) 0 ; + Handle temp4 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg4 = &temp4; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletFileName",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_api_Client_DecryptWallet",&obj0,&obj1,&obj2)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_Client_GetWalletFileName(arg1,arg2); + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string"); + } + (&arg2)->p = buffer; + (&arg2)->n = size - 1; + } + { + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_api_Client_DecryptWallet', expecting string"); + } + (&arg3)->p = buffer; + (&arg3)->n = size - 1; + } + result = (GoUint32)SKY_api_Client_DecryptWallet(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); } return resultobj; fail: @@ -21605,116 +21693,141 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWI } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Ripemd160_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__Ripemd160 *arg1 = (cipher__Ripemd160 *) 0 ; + GoSlice arg2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Ripemd160_Set",&obj0,&obj1)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); + cipher_Ripemd160* p = (cipher_Ripemd160*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletLabel",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_Ripemd160_Set', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_api_Handle_Client_GetWalletLabel(arg1,arg2); + result = (GoUint32)SKY_cipher_Ripemd160_Set((unsigned char (*)[20])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFullPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_HashRipemd160(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Client__Handle arg1 ; - WalletResponse__Handle arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString temp3 ; + GoSlice arg1 ; + cipher__Ripemd160 *arg2 = (cipher__Ripemd160 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_HashRipemd160",&obj0,&obj1)) SWIG_fail; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_Client_GetWalletFullPath",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_HashRipemd160', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } { - SWIG_AsVal_long(obj1, (long*)&arg2); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_Ripemd160, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type Ripemd160"); + cipher_Ripemd160* p = (cipher_Ripemd160*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_Handle_Client_GetWalletFullPath(arg1,arg2,arg3); + result = (GoUint32)SKY_cipher_HashRipemd160(arg1,(unsigned char (*)[20])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoStringMap_ *arg2 = (GoStringMap_ *) 0 ; - Handle temp2 ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + GoSlice arg2 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256_Set",&obj0,&obj1)) SWIG_fail; { - arg2 = &temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletMeta",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256_Set', expecting string"); + } + (&arg2)->data = buffer; + (&arg2)->len = size - 1; + (&arg2)->cap = size; } - result = (GoUint32)SKY_api_Handle_GetWalletMeta(arg1,arg2); + result = (GoUint32)SKY_cipher_SHA256_Set((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletEntriesCount",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - result = (GoUint32)SKY_api_Handle_GetWalletEntriesCount(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Hex",&obj0)) SWIG_fail; + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; + } + result = (GoUint32)SKY_cipher_SHA256_Hex((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -21722,73 +21835,78 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Xor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletResponseEntriesCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_SHA256_Xor",&obj0,&obj1,&obj2)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; } - result = (GoUint32)SKY_api_Handle_Client_GetWalletResponseEntriesCount(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; + } + result = (GoUint32)SKY_cipher_SHA256_Xor((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SumSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoUint32 arg2 ; - cipher__Address *arg3 = (cipher__Address *) 0 ; - cipher__PubKey *arg4 = (cipher__PubKey *) 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + GoSlice arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Handle_WalletGetEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SumSHA256",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); - } - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "3"" of type '" "cipher__Address *""'"); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SumSHA256', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - arg3 = (cipher__Address *)(argp3); { void *argp = 0; - int res = SWIG_ConvertPtr(obj3, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); if (!SWIG_IsOK(res)) - SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); - cipher_PubKey* p = (cipher_PubKey*)argp; - arg4 = &p->data; + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_Handle_WalletGetEntry(arg1,arg2,arg3,(unsigned char (*)[33])arg4); + result = (GoUint32)SKY_cipher_SumSHA256(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -21796,168 +21914,178 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletGetEntry(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256FromHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoUint32 arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString_ *arg4 = (GoString_ *) 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - GoString temp3 ; - GoString temp4 ; + GoString arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_SHA256FromHex",&obj0,&obj1)) SWIG_fail; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - { - temp4.p = NULL; - temp4.n = 0; - arg4 = (GoString_ *)&temp4; + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_SHA256FromHex', expecting string"); + } + (&arg1)->p = buffer; + (&arg1)->n = size - 1; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletResponseGetEntry",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletResponseGetEntry" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - result = (GoUint32)SKY_api_Handle_WalletResponseGetEntry(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_cipher_SHA256FromHex(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); - free( (void*)arg4->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseIsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_DoubleSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - GoUint8 temp2 ; - int res2 = SWIG_TMPOBJ ; + GoSlice arg1 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseIsEncrypted",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_DoubleSHA256",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + char* buffer = 0; + size_t size = 0; + int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cipher_DoubleSHA256', expecting string"); + } + (&arg1)->data = buffer; + (&arg1)->len = size - 1; + (&arg1)->cap = size; } - result = (GoUint32)SKY_api_Handle_WalletResponseIsEncrypted(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + { + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } + result = (GoUint32)SKY_cipher_DoubleSHA256(arg1,(unsigned char (*)[32])arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetCryptoType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_AddSHA256(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WalletResponse__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + cipher__SHA256 *arg3 = (cipher__SHA256 *) 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; GoUint32 result; + if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cipher_AddSHA256",&obj0,&obj1,&obj2)) SWIG_fail; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseGetCryptoType",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_Handle_WalletResponseGetCryptoType(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + void *argp = 0; + int res = SWIG_ConvertPtr(obj2, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg3 = &p->data; } + result = (GoUint32)SKY_cipher_AddSHA256((unsigned char (*)[32])arg1,(unsigned char (*)[32])arg2,(unsigned char (*)[32])arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_Merkle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallets__Handle arg1 ; - GoUint32 *arg2 = (GoUint32 *) 0 ; - GoUint32 temp2 ; - int res2 = SWIG_TMPOBJ ; + GoSlice *arg1 = (GoSlice *) 0 ; + cipher__SHA256 *arg2 = (cipher__SHA256 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; - arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletsResponseGetCount",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_cipher_Merkle",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_GoSlice, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_cipher_Merkle" "', argument " "1"" of type '" "GoSlice *""'"); + } + arg1 = (GoSlice *)(argp1); { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj1, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg2 = &p->data; } - result = (GoUint32)SKY_api_Handle_WalletsResponseGetCount(arg1,arg2); + result = (GoUint32)SKY_cipher_Merkle(arg1,(unsigned char (*)[32])arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - if (SWIG_IsTmpObj(res2)) { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); - } else { - int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_cipher_SHA256_Null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallets__Handle arg1 ; - GoUint32 arg2 ; - WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - Handle temp3 ; + cipher__SHA256 *arg1 = (cipher__SHA256 *) 0 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_cipher_SHA256_Null",&obj0)) SWIG_fail; { - arg3 = &temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletsResponseGetAt",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + void *argp = 0; + int res = SWIG_ConvertPtr(obj0, &argp, SWIGTYPE_p_cipher_SHA256, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type SHA256"); + cipher_SHA256* p = (cipher_SHA256*)argp; + arg1 = &p->data; } - ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletsResponseGetAt" "', argument " "2"" of type '" "GoUint32""'"); - } - arg2 = (GoUint32)(val2); - result = (GoUint32)SKY_api_Handle_WalletsResponseGetAt(arg1,arg2,arg3); + result = (GoUint32)SKY_cipher_SHA256_Null((unsigned char (*)[32])arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -21965,7 +22093,7 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_JsonEncode_Handle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; Handle arg1 ; GoString_ *arg2 = (GoString_ *) 0 ; @@ -21978,11 +22106,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGU temp2.n = 0; arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletFolderAddress",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_JsonEncode_Handle",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_GetWalletFolderAddress(arg1,arg2); + result = (GoUint32)SKY_JsonEncode_Handle(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); @@ -21994,28 +22122,26 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Progress_GetCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp2 = 0; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletSeed",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Progress_GetCurrent",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_GetWalletSeed(arg1,arg2); + result = (GoUint32)SKY_Handle_Progress_GetCurrent(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -22023,28 +22149,26 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletSeed(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadSeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + temp2 = 0; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletLastSeed",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadSeq",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_GetWalletLastSeed(arg1,arg2); + result = (GoUint32)SKY_Handle_Block_GetHeadSeq(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -22052,15 +22176,11 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetHeadHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - BuildInfo_Handle arg1 ; + Handle arg1 ; GoString_ *arg2 = (GoString_ *) 0 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString_ *arg4 = (GoString_ *) 0 ; GoString temp2 ; - GoString temp3 ; - GoString temp4 ; PyObject * obj0 = 0 ; GoUint32 result; @@ -22069,92 +22189,44 @@ SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDP temp2.n = 0; arg2 = (GoString_ *)&temp2; } - { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - { - temp4.p = NULL; - temp4.n = 0; - arg4 = (GoString_ *)&temp4; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetBuildInfoData",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetHeadHash",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_Handle_GetBuildInfoData(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_Handle_Block_GetHeadHash(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); free( (void*)arg2->p ); } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); - free( (void*)arg4->p ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_api_NewWalletResponse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Block_GetPreviousBlockHash(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - Wallet__Handle arg1 ; - WalletResponse__Handle *arg2 = (WalletResponse__Handle *) 0 ; - Handle temp2 ; + Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - arg2 = &temp2; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_NewWalletResponse",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Block_GetPreviousBlockHash",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_api_NewWalletResponse(arg1,arg2); - resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - GoString arg1 ; - WebRpcClient__Handle *arg2 = (WebRpcClient__Handle *) 0 ; - Handle temp2 ; - PyObject * obj0 = 0 ; - GoUint32 result; - - { - arg2 = &temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_NewClient",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_NewClient', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; - } - result = (GoUint32)SKY_webrpc_NewClient(arg1,arg2); + result = (GoUint32)SKY_Handle_Block_GetPreviousBlockHash(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22162,28 +22234,34 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_NewClient(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Handle arg1 ; + GoUint64 arg2 ; + Handle *arg3 = (Handle *) 0 ; + unsigned long long val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_webrpc_Client_CSRF",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Blocks_GetAt",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_webrpc_Client_CSRF(arg1,arg2); + ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Blocks_GetAt" "', argument " "2"" of type '" "GoUint64""'"); + } + arg2 = (GoUint64)(val2); + result = (GoUint32)SKY_Handle_Blocks_GetAt(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } return resultobj; fail: @@ -22191,33 +22269,26 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_CSRF(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_InjectTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Blocks_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - Transaction__Handle arg2 ; - GoString_ *arg3 = (GoString_ *) 0 ; - GoString temp3 ; + Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.p = NULL; - temp3.n = 0; - arg3 = (GoString_ *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_InjectTransaction",&obj0,&obj1)) SWIG_fail; - { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2 = 0; + arg2 = &temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Blocks_GetCount",&obj0)) SWIG_fail; { - SWIG_AsVal_long(obj1, (long*)&arg2); + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_webrpc_Client_InjectTransaction(arg1,arg2,arg3); + result = (GoUint32)SKY_Handle_Blocks_GetCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); - free( (void*)arg3->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); } return resultobj; fail: @@ -22225,156 +22296,110 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_InjectTransaction(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Connections_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - StatusResult_Handle *arg2 = (StatusResult_Handle *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + Handle arg1 ; + GoUint64 *arg2 = (GoUint64 *) 0 ; + GoUint64 temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetStatus",&obj0,&obj1)) SWIG_fail; { - SWIG_AsVal_long(obj0, (long*)&arg1); + temp2 = 0; + arg2 = &temp2; } - res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_StatusResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SKY_webrpc_Client_GetStatus" "', argument " "2"" of type '" "StatusResult_Handle *""'"); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Connections_GetCount",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); } - arg2 = (StatusResult_Handle *)(argp2); - result = (GoUint32)SKY_webrpc_Client_GetStatus(arg1,arg2); + result = (GoUint32)SKY_Handle_Connections_GetCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long( *arg2 )); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetTransactionByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString arg2 ; - TransactionResult_Handle *arg3 = (TransactionResult_Handle *) 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Strings__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetTransactionByID",&obj0,&obj1,&obj2)) SWIG_fail; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_GetCount",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetTransactionByID', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_TransactionResult_Handle, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_webrpc_Client_GetTransactionByID" "', argument " "3"" of type '" "TransactionResult_Handle *""'"); - } - arg3 = (TransactionResult_Handle *)(argp3); - result = (GoUint32)SKY_webrpc_Client_GetTransactionByID(arg1,arg2,arg3); + result = (GoUint32)SKY_Handle_Strings_GetCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetAddressUxOuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_Sort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoSlice arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoSlice_ temp3 ; + Strings__Handle arg1 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; - { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; - } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetAddressUxOuts",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_Handle_Strings_Sort",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetAddressUxOuts', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; - } - result = (GoUint32)SKY_webrpc_Client_GetAddressUxOuts(arg1,arg2,arg3); + result = (GoUint32)SKY_Handle_Strings_Sort(arg1); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_Handle_Strings_GetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoUint64 arg2 ; - GoUint64 arg3 ; - coin__UxArray *arg4 = (coin__UxArray *) 0 ; - unsigned long long val2 ; + Strings__Handle arg1 ; + GoInt arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + long long val2 ; int ecode2 = 0 ; - unsigned long long val3 ; - int ecode3 = 0 ; - GoSlice_ temp4 ; + GoString temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - temp4.data = NULL; - temp4.len = 0; - temp4.cap = 0; - arg4 = (coin__UxArray *)&temp4; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_webrpc_Client_GetBlocksInRange",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_Handle_Strings_GetAt",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); + ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SKY_webrpc_Client_GetBlocksInRange" "', argument " "3"" of type '" "GoUint64""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_Handle_Strings_GetAt" "', argument " "2"" of type '" "GoInt""'"); } - arg3 = (GoUint64)(val3); - result = (GoUint32)SKY_webrpc_Client_GetBlocksInRange(arg1,arg2,arg3,arg4); + arg2 = (GoInt)(val2); + result = (GoUint32)SKY_Handle_Strings_GetAt(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->data, arg4->len )); - free( (void*)arg4->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -22382,42 +22407,28 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksInRange(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoSlice arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - GoSlice_ temp3 ; + Client__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetBlocksBySeq",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletDir",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_webrpc_Client_GetBlocksBySeq', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; - } - result = (GoUint32)SKY_webrpc_Client_GetBlocksBySeq(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Handle_Client_GetWalletDir(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22425,38 +22436,28 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetBlocksBySeq(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoUint64 arg2 ; - coin__UxArray *arg3 = (coin__UxArray *) 0 ; - unsigned long long val2 ; - int ecode2 = 0 ; - GoSlice_ temp3 ; + WalletResponse__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; GoUint32 result; { - temp3.data = NULL; - temp3.len = 0; - temp3.cap = 0; - arg3 = (coin__UxArray *)&temp3; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OO:SKY_webrpc_Client_GetLastBlocks",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletFileName",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } - ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_webrpc_Client_GetLastBlocks" "', argument " "2"" of type '" "GoUint64""'"); - } - arg2 = (GoUint64)(val2); - result = (GoUint32)SKY_webrpc_Client_GetLastBlocks(arg1,arg2,arg3); + result = (GoUint32)SKY_api_Handle_Client_GetWalletFileName(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->data, arg3->len )); - free( (void*)arg3->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22464,23 +22465,28 @@ SWIGINTERN PyObject *_wrap_SKY_webrpc_Client_GetLastBlocks(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString_ *arg1 = (GoString_ *) 0 ; - GoString temp1 ; + WalletResponse__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; GoUint32 result; { - temp1.p = NULL; - temp1.n = 0; - arg1 = (GoString_ *)&temp1; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)":SKY_bip39_NewDefaultMnemomic")) SWIG_fail; - result = (GoUint32)SKY_bip39_NewDefaultMnemomic(arg1); + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletLabel",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Handle_Client_GetWalletLabel(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg1->p, arg1->n )); - free( (void*)arg1->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22488,33 +22494,33 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewDefaultMnemomic(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletFullPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoInt arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - long long val1 ; - int ecode1 = 0 ; - GoSlice_ temp2 ; + Client__Handle arg1 ; + WalletResponse__Handle arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString temp3 ; PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; GoUint32 result; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewEntropy",&obj0)) SWIG_fail; - ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SKY_bip39_NewEntropy" "', argument " "1"" of type '" "GoInt""'"); - } - arg1 = (GoInt)(val1); - result = (GoUint32)SKY_bip39_NewEntropy(arg1,arg2); + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_Client_GetWalletFullPath",&obj0,&obj1)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + { + SWIG_AsVal_long(obj1, (long*)&arg2); + } + result = (GoUint32)SKY_api_Handle_Client_GetWalletFullPath(arg1,arg2,arg3); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); } return resultobj; fail: @@ -22522,36 +22528,25 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewEntropy(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoString_ *arg2 = (GoString_ *) 0 ; - GoString temp2 ; + Wallet__Handle arg1 ; + GoStringMap_ *arg2 = (GoStringMap_ *) 0 ; + Handle temp2 ; PyObject * obj0 = 0 ; GoUint32 result; { - temp2.p = NULL; - temp2.n = 0; - arg2 = (GoString_ *)&temp2; + arg2 = &temp2; } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_NewMnemonic",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletMeta",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_NewMnemonic', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_bip39_NewMnemonic(arg1,arg2); + result = (GoUint32)SKY_api_Handle_GetWalletMeta(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); - free( (void*)arg2->p ); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg2)); } return resultobj; fail: @@ -22559,36 +22554,27 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_NewMnemonic(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - coin__UxArray *arg2 = (coin__UxArray *) 0 ; - GoSlice_ temp2 ; + Wallet__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; GoUint32 result; + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletEntriesCount",&obj0)) SWIG_fail; { - temp2.data = NULL; - temp2.len = 0; - temp2.cap = 0; - arg2 = (coin__UxArray *)&temp2; - } - if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_MnemonicToByteArray",&obj0)) SWIG_fail; - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_MnemonicToByteArray', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_bip39_MnemonicToByteArray(arg1,arg2); + result = (GoUint32)SKY_api_Handle_GetWalletEntriesCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->data, arg2->len )); - free( (void*)arg2->data ); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -22596,34 +22582,27 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_MnemonicToByteArray(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_Client_GetWalletResponseEntriesCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoString arg1 ; - GoUint8 *arg2 = (GoUint8 *) 0 ; - GoUint8 temp2 ; + WalletResponse__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; int res2 = SWIG_TMPOBJ ; PyObject * obj0 = 0 ; GoUint32 result; arg2 = &temp2; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_bip39_IsMnemonicValid",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_Client_GetWalletResponseEntriesCount",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_bip39_IsMnemonicValid', expecting string"); - } - (&arg1)->p = buffer; - (&arg1)->n = size - 1; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_bip39_IsMnemonicValid(arg1,arg2); + result = (GoUint32)SKY_api_Handle_Client_GetWalletResponseEntriesCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); if (SWIG_IsTmpObj(res2)) { resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); } else { int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -22631,77 +22610,122 @@ SWIGINTERN PyObject *_wrap_SKY_bip39_IsMnemonicValid(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoSlice arg4 ; - PasswordReader__Handle arg5 ; - Transaction__Handle *arg6 = (Transaction__Handle *) 0 ; - void *argp5 ; - int res5 = 0 ; - Handle temp6 ; + Wallet__Handle arg1 ; + GoUint32 arg2 ; + cipher__Address *arg3 = (cipher__Address *) 0 ; + cipher__PubKey *arg4 = (cipher__PubKey *) 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; PyObject * obj2 = 0 ; PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; GoUint32 result; - { - arg6 = &temp6; - } - if (!PyArg_ParseTuple(args,(char *)"OOOOO:SKY_cli_CreateRawTxFromWallet",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OOOO:SKY_api_Handle_WalletGetEntry",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_cipher__Address, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SKY_api_Handle_WalletGetEntry" "', argument " "3"" of type '" "cipher__Address *""'"); + } + arg3 = (cipher__Address *)(argp3); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; + void *argp = 0; + int res = SWIG_ConvertPtr(obj3, &argp, SWIGTYPE_p_cipher_PubKey, 0 | 0); + if (!SWIG_IsOK(res)) + SWIG_exception_fail(SWIG_TypeError, "expecting type PubKey"); + cipher_PubKey* p = (cipher_PubKey*)argp; + arg4 = &p->data; } + result = (GoUint32)SKY_api_Handle_WalletGetEntry(arg1,arg2,arg3,(unsigned char (*)[33])arg4); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + WalletResponse__Handle arg1 ; + GoUint32 arg2 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString_ *arg4 = (GoString_ *) 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + GoString temp3 ; + GoString temp4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + GoUint32 result; + { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; } { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromWallet', expecting string"); - } - (&arg4)->data = buffer; - (&arg4)->len = size - 1; - (&arg4)->cap = size; + temp4.p = NULL; + temp4.n = 0; + arg4 = (GoString_ *)&temp4; } + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletResponseGetEntry",&obj0,&obj1)) SWIG_fail; { - res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_PasswordReader__Handle, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromWallet" "', argument " "5"" of type '" "PasswordReader__Handle""'"); - } else { - arg5 = *((PasswordReader__Handle *)(argp5)); - } + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_CreateRawTxFromWallet(arg1,arg2,arg3,arg4,arg5,arg6); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletResponseGetEntry" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + result = (GoUint32)SKY_api_Handle_WalletResponseGetEntry(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg6)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); + free( (void*)arg4->p ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseIsEncrypted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + WalletResponse__Handle arg1 ; + GoUint8 *arg2 = (GoUint8 *) 0 ; + GoUint8 temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + GoUint32 result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseIsEncrypted",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Handle_WalletResponseIsEncrypted(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags)); } return resultobj; fail: @@ -22709,89 +22733,56 @@ SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromWallet(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletResponseGetCryptoType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - GoString arg2 ; - GoString arg3 ; - GoString arg4 ; - GoSlice arg5 ; - PasswordReader__Handle arg6 ; - Transaction__Handle *arg7 = (Transaction__Handle *) 0 ; - void *argp6 ; - int res6 = 0 ; - Handle temp7 ; + WalletResponse__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; GoUint32 result; { - arg7 = &temp7; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTxFromAddress",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletResponseGetCryptoType",&obj0)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } + result = (GoUint32)SKY_api_Handle_WalletResponseGetCryptoType(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); - } - (&arg2)->p = buffer; - (&arg2)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); - } - (&arg3)->p = buffer; - (&arg3)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); - } - (&arg4)->p = buffer; - (&arg4)->n = size - 1; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTxFromAddress', expecting string"); - } - (&arg5)->data = buffer; - (&arg5)->len = size - 1; - (&arg5)->cap = size; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Wallets__Handle arg1 ; + GoUint32 *arg2 = (GoUint32 *) 0 ; + GoUint32 temp2 ; + int res2 = SWIG_TMPOBJ ; + PyObject * obj0 = 0 ; + GoUint32 result; + + arg2 = &temp2; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_WalletsResponseGetCount",&obj0)) SWIG_fail; { - res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_PasswordReader__Handle, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SKY_cli_CreateRawTxFromAddress" "', argument " "6"" of type '" "PasswordReader__Handle""'"); - } else { - arg6 = *((PasswordReader__Handle *)(argp6)); - } + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_CreateRawTxFromAddress(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + result = (GoUint32)SKY_api_Handle_WalletsResponseGetCount(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); - { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7)); + if (SWIG_IsTmpObj(res2)) { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2))); + } else { + int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags)); } return resultobj; fail: @@ -22799,81 +22790,63 @@ SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTxFromAddress(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_WalletsResponseGetAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - WebRpcClient__Handle arg1 ; - Wallet__Handle arg2 ; - GoSlice arg3 ; - GoString arg4 ; - GoSlice arg5 ; - GoSlice arg6 ; - Transaction__Handle *arg7 = (Transaction__Handle *) 0 ; - Handle temp7 ; + Wallets__Handle arg1 ; + GoUint32 arg2 ; + WalletResponse__Handle *arg3 = (WalletResponse__Handle *) 0 ; + unsigned int val2 ; + int ecode2 = 0 ; + Handle temp3 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; - PyObject * obj3 = 0 ; - PyObject * obj4 = 0 ; - PyObject * obj5 = 0 ; GoUint32 result; { - arg7 = &temp7; + arg3 = &temp3; } - if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SKY_cli_CreateRawTx",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO:SKY_api_Handle_WalletsResponseGetAt",&obj0,&obj1)) SWIG_fail; { SWIG_AsVal_long(obj0, (long*)&arg1); } + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SKY_api_Handle_WalletsResponseGetAt" "', argument " "2"" of type '" "GoUint32""'"); + } + arg2 = (GoUint32)(val2); + result = (GoUint32)SKY_api_Handle_WalletsResponseGetAt(arg1,arg2,arg3); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - SWIG_AsVal_long(obj1, (long*)&arg2); - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); - } - (&arg3)->data = buffer; - (&arg3)->len = size - 1; - (&arg3)->cap = size; - } - { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj3, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); - } - (&arg4)->p = buffer; - (&arg4)->n = size - 1; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg3)); } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletFolderAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj4, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); - } - (&arg5)->data = buffer; - (&arg5)->len = size - 1; - (&arg5)->cap = size; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletFolderAddress",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj5, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_CreateRawTx', expecting string"); - } - (&arg6)->data = buffer; - (&arg6)->len = size - 1; - (&arg6)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_CreateRawTx(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + result = (GoUint32)SKY_api_Handle_GetWalletFolderAddress(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg7)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22881,59 +22854,57 @@ SWIGINTERN PyObject *_wrap_SKY_cli_CreateRawTx(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SKY_cli_NewTransaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - GoSlice arg1 ; - GoSlice arg2 ; - GoSlice arg3 ; - Transaction__Handle *arg4 = (Transaction__Handle *) 0 ; - Handle temp4 ; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; PyObject * obj0 = 0 ; - PyObject * obj1 = 0 ; - PyObject * obj2 = 0 ; GoUint32 result; { - arg4 = &temp4; + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - if (!PyArg_ParseTuple(args,(char *)"OOO:SKY_cli_NewTransaction",&obj0,&obj1,&obj2)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletSeed",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj0, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); - } - (&arg1)->data = buffer; - (&arg1)->len = size - 1; - (&arg1)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } + result = (GoUint32)SKY_api_Handle_GetWalletSeed(arg1,arg2); + resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj1, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); - } - (&arg2)->data = buffer; - (&arg2)->len = size - 1; - (&arg2)->cap = size; + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetWalletLastSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Wallet__Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString temp2 ; + PyObject * obj0 = 0 ; + GoUint32 result; + + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetWalletLastSeed",&obj0)) SWIG_fail; { - char* buffer = 0; - size_t size = 0; - int res = SWIG_AsCharPtrAndSize( obj2, &buffer, &size, 0 ); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_TypeError, "in method 'SKY_cli_NewTransaction', expecting string"); - } - (&arg3)->data = buffer; - (&arg3)->len = size - 1; - (&arg3)->cap = size; + SWIG_AsVal_long(obj0, (long*)&arg1); } - result = (GoUint32)SKY_cli_NewTransaction(arg1,arg2,arg3,arg4); + result = (GoUint32)SKY_api_Handle_GetWalletLastSeed(arg1,arg2); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); { - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long(*arg4)); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); } return resultobj; fail: @@ -22941,34 +22912,63 @@ SWIGINTERN PyObject *_wrap_SKY_cli_NewTransaction(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_testutil_MakeAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_api_Handle_GetBuildInfoData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - cipher__Address *arg1 = (cipher__Address *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + BuildInfo_Handle arg1 ; + GoString_ *arg2 = (GoString_ *) 0 ; + GoString_ *arg3 = (GoString_ *) 0 ; + GoString_ *arg4 = (GoString_ *) 0 ; + GoString temp2 ; + GoString temp3 ; + GoString temp4 ; PyObject * obj0 = 0 ; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)"O:SKY_testutil_MakeAddress",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cipher__Address, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SKY_testutil_MakeAddress" "', argument " "1"" of type '" "cipher__Address *""'"); + { + temp2.p = NULL; + temp2.n = 0; + arg2 = (GoString_ *)&temp2; } - arg1 = (cipher__Address *)(argp1); - result = (GoUint32)SKY_testutil_MakeAddress(arg1); + { + temp3.p = NULL; + temp3.n = 0; + arg3 = (GoString_ *)&temp3; + } + { + temp4.p = NULL; + temp4.n = 0; + arg4 = (GoString_ *)&temp4; + } + if (!PyArg_ParseTuple(args,(char *)"O:SKY_api_Handle_GetBuildInfoData",&obj0)) SWIG_fail; + { + SWIG_AsVal_long(obj0, (long*)&arg1); + } + result = (GoUint32)SKY_api_Handle_GetBuildInfoData(arg1,arg2,arg3,arg4); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg2->p, arg2->n )); + free( (void*)arg2->p ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg3->p, arg3->n )); + free( (void*)arg3->p ); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtrAndSize( arg4->p, arg4->n )); + free( (void*)arg4->p ); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_logging_EnableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchInterruptPanic")) SWIG_fail; - result = (GoUint32)SKY_apputil_CatchInterruptPanic(); + if (!PyArg_ParseTuple(args,(char *)":SKY_logging_EnableColors")) SWIG_fail; + result = (GoUint32)SKY_logging_EnableColors(); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -22976,12 +22976,12 @@ SWIGINTERN PyObject *_wrap_SKY_apputil_CatchInterruptPanic(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_logging_DisableColors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_CatchDebug")) SWIG_fail; - result = (GoUint32)SKY_apputil_CatchDebug(); + if (!PyArg_ParseTuple(args,(char *)":SKY_logging_DisableColors")) SWIG_fail; + result = (GoUint32)SKY_logging_DisableColors(); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -22989,12 +22989,12 @@ SWIGINTERN PyObject *_wrap_SKY_apputil_CatchDebug(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SKY_apputil_PrintProgramStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SKY_logging_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; GoUint32 result; - if (!PyArg_ParseTuple(args,(char *)":SKY_apputil_PrintProgramStatus")) SWIG_fail; - result = (GoUint32)SKY_apputil_PrintProgramStatus(); + if (!PyArg_ParseTuple(args,(char *)":SKY_logging_Disable")) SWIG_fail; + result = (GoUint32)SKY_logging_Disable(); resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result)); return resultobj; fail: @@ -28151,17 +28151,108 @@ static PyMethodDef SwigMethods[] = { { (char *)"new_GoSlice", _wrap_new_GoSlice, METH_VARARGS, NULL}, { (char *)"delete_GoSlice", _wrap_delete_GoSlice, METH_VARARGS, NULL}, { (char *)"GoSlice_swigregister", GoSlice_swigregister, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Ripemd160_Set", _wrap_SKY_cipher_Ripemd160_Set, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_HashRipemd160", _wrap_SKY_cipher_HashRipemd160, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SHA256_Set", _wrap_SKY_cipher_SHA256_Set, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SHA256_Hex", _wrap_SKY_cipher_SHA256_Hex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SHA256_Xor", _wrap_SKY_cipher_SHA256_Xor, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SumSHA256", _wrap_SKY_cipher_SumSHA256, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SHA256FromHex", _wrap_SKY_cipher_SHA256FromHex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_DoubleSHA256", _wrap_SKY_cipher_DoubleSHA256, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_AddSHA256", _wrap_SKY_cipher_AddSHA256, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Merkle", _wrap_SKY_cipher_Merkle, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SHA256_Null", _wrap_SKY_cipher_SHA256_Null, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_RandByte", _wrap_SKY_cipher_RandByte, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_NewPubKey", _wrap_SKY_cipher_NewPubKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKeyFromHex", _wrap_SKY_cipher_PubKeyFromHex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKeyFromSecKey", _wrap_SKY_cipher_PubKeyFromSecKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKeyFromSig", _wrap_SKY_cipher_PubKeyFromSig, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKey_Verify", _wrap_SKY_cipher_PubKey_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKey_Hex", _wrap_SKY_cipher_PubKey_Hex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_PubKeyRipemd160", _wrap_SKY_cipher_PubKeyRipemd160, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_NewSecKey", _wrap_SKY_cipher_NewSecKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SecKeyFromHex", _wrap_SKY_cipher_SecKeyFromHex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SecKey_Verify", _wrap_SKY_cipher_SecKey_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SecKey_Hex", _wrap_SKY_cipher_SecKey_Hex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_ECDH", _wrap_SKY_cipher_ECDH, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_NewSig", _wrap_SKY_cipher_NewSig, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SigFromHex", _wrap_SKY_cipher_SigFromHex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Sig_Hex", _wrap_SKY_cipher_Sig_Hex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SignHash", _wrap_SKY_cipher_SignHash, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_VerifyAddressSignedHash", _wrap_SKY_cipher_VerifyAddressSignedHash, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_VerifySignedHash", _wrap_SKY_cipher_VerifySignedHash, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_VerifyPubKeySignedHash", _wrap_SKY_cipher_VerifyPubKeySignedHash, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_GenerateKeyPair", _wrap_SKY_cipher_GenerateKeyPair, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_GenerateDeterministicKeyPair", _wrap_SKY_cipher_GenerateDeterministicKeyPair, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_DeterministicKeyPairIterator", _wrap_SKY_cipher_DeterministicKeyPairIterator, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_GenerateDeterministicKeyPairs", _wrap_SKY_cipher_GenerateDeterministicKeyPairs, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_GenerateDeterministicKeyPairsSeed", _wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_CheckSecKey", _wrap_SKY_cipher_CheckSecKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_CheckSecKeyHash", _wrap_SKY_cipher_CheckSecKeyHash, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_DecodeBase58BitcoinAddress", _wrap_SKY_cipher_DecodeBase58BitcoinAddress, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddressFromPubKey", _wrap_SKY_cipher_BitcoinAddressFromPubKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddressFromSecKey", _wrap_SKY_cipher_BitcoinAddressFromSecKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinWalletImportFormatFromSeckey", _wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddressFromBytes", _wrap_SKY_cipher_BitcoinAddressFromBytes, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SecKeyFromBitcoinWalletImportFormat", _wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddress_Null", _wrap_SKY_cipher_BitcoinAddress_Null, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddress_Bytes", _wrap_SKY_cipher_BitcoinAddress_Bytes, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddress_Verify", _wrap_SKY_cipher_BitcoinAddress_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddress_String", _wrap_SKY_cipher_BitcoinAddress_String, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_BitcoinAddress_Checksum", _wrap_SKY_cipher_BitcoinAddress_Checksum, METH_VARARGS, NULL}, + { (char *)"SKY_api_NewCreateTransactionResponse", _wrap_SKY_api_NewCreateTransactionResponse, METH_VARARGS, NULL}, + { (char *)"SKY_api_NewCreatedTransaction", _wrap_SKY_api_NewCreatedTransaction, METH_VARARGS, NULL}, + { (char *)"SKY_api_CreatedTransaction_ToTransaction", _wrap_SKY_api_CreatedTransaction_ToTransaction, METH_VARARGS, NULL}, + { (char *)"SKY_api_NewCreatedTransactionOutput", _wrap_SKY_api_NewCreatedTransactionOutput, METH_VARARGS, NULL}, + { (char *)"SKY_api_NewCreatedTransactionInput", _wrap_SKY_api_NewCreatedTransactionInput, METH_VARARGS, NULL}, + { (char *)"SKY_iputil_LocalhostIP", _wrap_SKY_iputil_LocalhostIP, METH_VARARGS, NULL}, + { (char *)"SKY_iputil_IsLocalhost", _wrap_SKY_iputil_IsLocalhost, METH_VARARGS, NULL}, + { (char *)"SKY_iputil_SplitAddr", _wrap_SKY_iputil_SplitAddr, METH_VARARGS, NULL}, + { (char *)"SKY_testutil_MakeAddress", _wrap_SKY_testutil_MakeAddress, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Create_Transaction", _wrap_SKY_coin_Create_Transaction, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_Copy", _wrap_SKY_coin_Transaction_Copy, METH_VARARGS, NULL}, + { (char *)"SKY_coin_GetTransactionObject", _wrap_SKY_coin_GetTransactionObject, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_ResetInputs", _wrap_SKY_coin_Transaction_ResetInputs, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetInputsCount", _wrap_SKY_coin_Transaction_GetInputsCount, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetInputAt", _wrap_SKY_coin_Transaction_GetInputAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_SetInputAt", _wrap_SKY_coin_Transaction_SetInputAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetOutputsCount", _wrap_SKY_coin_Transaction_GetOutputsCount, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetOutputAt", _wrap_SKY_coin_Transaction_GetOutputAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_SetOutputAt", _wrap_SKY_coin_Transaction_SetOutputAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetSignaturesCount", _wrap_SKY_coin_Transaction_GetSignaturesCount, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_GetSignatureAt", _wrap_SKY_coin_Transaction_GetSignatureAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_SetSignatureAt", _wrap_SKY_coin_Transaction_SetSignatureAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_PushSignature", _wrap_SKY_coin_Transaction_PushSignature, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_ResetOutputs", _wrap_SKY_coin_Transaction_ResetOutputs, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_ResetSignatures", _wrap_SKY_coin_Transaction_ResetSignatures, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_Verify", _wrap_SKY_coin_Transaction_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_VerifyInput", _wrap_SKY_coin_Transaction_VerifyInput, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_PushInput", _wrap_SKY_coin_Transaction_PushInput, METH_VARARGS, NULL}, + { (char *)"SKY_coin_TransactionOutput_UxID", _wrap_SKY_coin_TransactionOutput_UxID, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_PushOutput", _wrap_SKY_coin_Transaction_PushOutput, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_SignInputs", _wrap_SKY_coin_Transaction_SignInputs, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_Size", _wrap_SKY_coin_Transaction_Size, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_Hash", _wrap_SKY_coin_Transaction_Hash, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_SizeHash", _wrap_SKY_coin_Transaction_SizeHash, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_TxID", _wrap_SKY_coin_Transaction_TxID, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_TxIDHex", _wrap_SKY_coin_Transaction_TxIDHex, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_UpdateHeader", _wrap_SKY_coin_Transaction_UpdateHeader, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_HashInner", _wrap_SKY_coin_Transaction_HashInner, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_Serialize", _wrap_SKY_coin_Transaction_Serialize, METH_VARARGS, NULL}, + { (char *)"SKY_coin_TransactionDeserialize", _wrap_SKY_coin_TransactionDeserialize, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transaction_OutputHours", _wrap_SKY_coin_Transaction_OutputHours, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Create_Transactions", _wrap_SKY_coin_Create_Transactions, METH_VARARGS, NULL}, + { (char *)"SKY_coin_GetTransactionsObject", _wrap_SKY_coin_GetTransactionsObject, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_Length", _wrap_SKY_coin_Transactions_Length, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_Add", _wrap_SKY_coin_Transactions_Add, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_Fees", _wrap_SKY_coin_Transactions_Fees, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_GetAt", _wrap_SKY_coin_Transactions_GetAt, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_Hashes", _wrap_SKY_coin_Transactions_Hashes, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_Size", _wrap_SKY_coin_Transactions_Size, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Transactions_TruncateBytesTo", _wrap_SKY_coin_Transactions_TruncateBytesTo, METH_VARARGS, NULL}, + { (char *)"SKY_coin_SortTransactions", _wrap_SKY_coin_SortTransactions, METH_VARARGS, NULL}, + { (char *)"SKY_coin_NewSortableTransactions", _wrap_SKY_coin_NewSortableTransactions, METH_VARARGS, NULL}, + { (char *)"SKY_coin_SortableTransactions_Sort", _wrap_SKY_coin_SortableTransactions_Sort, METH_VARARGS, NULL}, + { (char *)"SKY_coin_SortableTransactions_Len", _wrap_SKY_coin_SortableTransactions_Len, METH_VARARGS, NULL}, + { (char *)"SKY_coin_SortableTransactions_Less", _wrap_SKY_coin_SortableTransactions_Less, METH_VARARGS, NULL}, + { (char *)"SKY_coin_SortableTransactions_Swap", _wrap_SKY_coin_SortableTransactions_Swap, METH_VARARGS, NULL}, + { (char *)"SKY_coin_VerifyTransactionCoinsSpending", _wrap_SKY_coin_VerifyTransactionCoinsSpending, METH_VARARGS, NULL}, + { (char *)"SKY_coin_VerifyTransactionHoursSpending", _wrap_SKY_coin_VerifyTransactionHoursSpending, METH_VARARGS, NULL}, + { (char *)"SKY_encrypt_ScryptChacha20poly1305_Encrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt, METH_VARARGS, NULL}, + { (char *)"SKY_encrypt_ScryptChacha20poly1305_Decrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt, METH_VARARGS, NULL}, + { (char *)"SKY_cli_GenerateWallet", _wrap_SKY_cli_GenerateWallet, METH_VARARGS, NULL}, + { (char *)"SKY_cli_MakeAlphanumericSeed", _wrap_SKY_cli_MakeAlphanumericSeed, METH_VARARGS, NULL}, + { (char *)"SKY_cli_AddPrivateKey", _wrap_SKY_cli_AddPrivateKey, METH_VARARGS, NULL}, + { (char *)"SKY_cli_AddPrivateKeyToFile", _wrap_SKY_cli_AddPrivateKeyToFile, METH_VARARGS, NULL}, { (char *)"SKY_base58_String2Hex", _wrap_SKY_base58_String2Hex, METH_VARARGS, NULL}, { (char *)"SKY_base58_Base58_ToInt", _wrap_SKY_base58_Base58_ToInt, METH_VARARGS, NULL}, { (char *)"SKY_base58_Base58_ToHex", _wrap_SKY_base58_Base58_ToHex, METH_VARARGS, NULL}, @@ -28172,10 +28263,23 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_base58_Hex2Base58", _wrap_SKY_base58_Hex2Base58, METH_VARARGS, NULL}, { (char *)"SKY_base58_Hex2Base58String", _wrap_SKY_base58_Hex2Base58String, METH_VARARGS, NULL}, { (char *)"SKY_base58_Hex2Base58Str", _wrap_SKY_base58_Hex2Base58Str, METH_VARARGS, NULL}, + { (char *)"SKY_handle_close", _wrap_SKY_handle_close, METH_VARARGS, NULL}, + { (char *)"SKY_handle_copy", _wrap_SKY_handle_copy, METH_VARARGS, NULL}, + { (char *)"SKY_apputil_CatchInterruptPanic", _wrap_SKY_apputil_CatchInterruptPanic, METH_VARARGS, NULL}, + { (char *)"SKY_apputil_CatchDebug", _wrap_SKY_apputil_CatchDebug, METH_VARARGS, NULL}, + { (char *)"SKY_apputil_PrintProgramStatus", _wrap_SKY_apputil_PrintProgramStatus, METH_VARARGS, NULL}, + { (char *)"SKY_fee_VerifyTransactionFee", _wrap_SKY_fee_VerifyTransactionFee, METH_VARARGS, NULL}, + { (char *)"SKY_fee_VerifyTransactionFeeForHours", _wrap_SKY_fee_VerifyTransactionFeeForHours, METH_VARARGS, NULL}, + { (char *)"SKY_fee_RequiredFee", _wrap_SKY_fee_RequiredFee, METH_VARARGS, NULL}, + { (char *)"SKY_fee_RemainingHours", _wrap_SKY_fee_RemainingHours, METH_VARARGS, NULL}, + { (char *)"SKY_fee_TransactionFee", _wrap_SKY_fee_TransactionFee, METH_VARARGS, NULL}, { (char *)"SKY_cli_GenerateAddressesInFile", _wrap_SKY_cli_GenerateAddressesInFile, METH_VARARGS, NULL}, { (char *)"SKY_cli_FormatAddressesAsJSON", _wrap_SKY_cli_FormatAddressesAsJSON, METH_VARARGS, NULL}, { (char *)"SKY_cli_FormatAddressesAsJoinedArray", _wrap_SKY_cli_FormatAddressesAsJoinedArray, METH_VARARGS, NULL}, { (char *)"SKY_cli_AddressesToStrings", _wrap_SKY_cli_AddressesToStrings, METH_VARARGS, NULL}, + { (char *)"SKY_cli_CheckWalletBalance", _wrap_SKY_cli_CheckWalletBalance, METH_VARARGS, NULL}, + { (char *)"SKY_cli_GetBalanceOfAddresses", _wrap_SKY_cli_GetBalanceOfAddresses, METH_VARARGS, NULL}, + { (char *)"SKY_certutil_NewTLSCertPair", _wrap_SKY_certutil_NewTLSCertPair, METH_VARARGS, NULL}, { (char *)"SKY_coin_NewBlock", _wrap_SKY_coin_NewBlock, METH_VARARGS, NULL}, { (char *)"SKY_coin_SignedBlock_VerifySignature", _wrap_SKY_coin_SignedBlock_VerifySignature, METH_VARARGS, NULL}, { (char *)"SKY_coin_NewGenesisBlock", _wrap_SKY_coin_NewGenesisBlock, METH_VARARGS, NULL}, @@ -28199,6 +28303,63 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_coin_GetBlockObject", _wrap_SKY_coin_GetBlockObject, METH_VARARGS, NULL}, { (char *)"SKY_coin_GetBlockBody", _wrap_SKY_coin_GetBlockBody, METH_VARARGS, NULL}, { (char *)"SKY_coin_NewEmptyBlock", _wrap_SKY_coin_NewEmptyBlock, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_NewError", _wrap_SKY_wallet_NewError, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_NewWallet", _wrap_SKY_wallet_NewWallet, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Lock", _wrap_SKY_wallet_Wallet_Lock, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Unlock", _wrap_SKY_wallet_Wallet_Unlock, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Load", _wrap_SKY_wallet_Load, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Save", _wrap_SKY_wallet_Wallet_Save, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Validate", _wrap_SKY_wallet_Wallet_Validate, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Type", _wrap_SKY_wallet_Wallet_Type, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Version", _wrap_SKY_wallet_Wallet_Version, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Filename", _wrap_SKY_wallet_Wallet_Filename, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_Label", _wrap_SKY_wallet_Wallet_Label, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_IsEncrypted", _wrap_SKY_wallet_Wallet_IsEncrypted, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_GenerateAddresses", _wrap_SKY_wallet_Wallet_GenerateAddresses, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_GetAddresses", _wrap_SKY_wallet_Wallet_GetAddresses, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_GetEntry", _wrap_SKY_wallet_Wallet_GetEntry, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Wallet_AddEntry", _wrap_SKY_wallet_Wallet_AddEntry, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_DistributeSpendHours", _wrap_SKY_wallet_DistributeSpendHours, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_DistributeCoinHoursProportional", _wrap_SKY_wallet_DistributeCoinHoursProportional, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_NewUxBalances", _wrap_SKY_wallet_NewUxBalances, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_NewUxBalance", _wrap_SKY_wallet_NewUxBalance, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_ChooseSpendsMinimizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_ChooseSpendsMaximizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts, METH_VARARGS, NULL}, + { (char *)"SKY_cli_GetWalletOutputsFromFile", _wrap_SKY_cli_GetWalletOutputsFromFile, METH_VARARGS, NULL}, + { (char *)"SKY_cli_GetWalletOutputs", _wrap_SKY_cli_GetWalletOutputs, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_DecodeBase58Address", _wrap_SKY_cipher_DecodeBase58Address, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_AddressFromBytes", _wrap_SKY_cipher_AddressFromBytes, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_AddressFromPubKey", _wrap_SKY_cipher_AddressFromPubKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_AddressFromSecKey", _wrap_SKY_cipher_AddressFromSecKey, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Address_Null", _wrap_SKY_cipher_Address_Null, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Address_Bytes", _wrap_SKY_cipher_Address_Bytes, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Address_Verify", _wrap_SKY_cipher_Address_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Address_String", _wrap_SKY_cipher_Address_String, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Address_Checksum", _wrap_SKY_cipher_Address_Checksum, METH_VARARGS, NULL}, + { (char *)"SKY_coin_AddUint64", _wrap_SKY_coin_AddUint64, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Uint64ToInt64", _wrap_SKY_coin_Uint64ToInt64, METH_VARARGS, NULL}, + { (char *)"SKY_coin_Int64ToUint64", _wrap_SKY_coin_Int64ToUint64, METH_VARARGS, NULL}, + { (char *)"SKY_coin_IntToUint32", _wrap_SKY_coin_IntToUint32, METH_VARARGS, NULL}, + { (char *)"SKY_map_Get", _wrap_SKY_map_Get, METH_VARARGS, NULL}, + { (char *)"SKY_map_HasKey", _wrap_SKY_map_HasKey, METH_VARARGS, NULL}, + { (char *)"SKY_map_Close", _wrap_SKY_map_Close, METH_VARARGS, NULL}, + { (char *)"SKY_cli_CreateRawTxFromWallet", _wrap_SKY_cli_CreateRawTxFromWallet, METH_VARARGS, NULL}, + { (char *)"SKY_cli_CreateRawTxFromAddress", _wrap_SKY_cli_CreateRawTxFromAddress, METH_VARARGS, NULL}, + { (char *)"SKY_cli_CreateRawTx", _wrap_SKY_cli_CreateRawTx, METH_VARARGS, NULL}, + { (char *)"SKY_cli_NewTransaction", _wrap_SKY_cli_NewTransaction, METH_VARARGS, NULL}, + { (char *)"SKY_file_InitDataDir", _wrap_SKY_file_InitDataDir, METH_VARARGS, NULL}, + { (char *)"SKY_file_UserHome", _wrap_SKY_file_UserHome, METH_VARARGS, NULL}, + { (char *)"SKY_file_ResolveResourceDirectory", _wrap_SKY_file_ResolveResourceDirectory, METH_VARARGS, NULL}, + { (char *)"SKY_file_DetermineResourcePath", _wrap_SKY_file_DetermineResourcePath, METH_VARARGS, NULL}, + { (char *)"SKY_api_NewWalletResponse", _wrap_SKY_api_NewWalletResponse, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_CryptoTypeFromString", _wrap_SKY_wallet_CryptoTypeFromString, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Entry_Verify", _wrap_SKY_wallet_Entry_Verify, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_Entry_VerifyPublic", _wrap_SKY_wallet_Entry_VerifyPublic, METH_VARARGS, NULL}, + { (char *)"SKY_bip39_NewDefaultMnemomic", _wrap_SKY_bip39_NewDefaultMnemomic, METH_VARARGS, NULL}, + { (char *)"SKY_bip39_NewEntropy", _wrap_SKY_bip39_NewEntropy, METH_VARARGS, NULL}, + { (char *)"SKY_bip39_NewMnemonic", _wrap_SKY_bip39_NewMnemonic, METH_VARARGS, NULL}, + { (char *)"SKY_bip39_MnemonicToByteArray", _wrap_SKY_bip39_MnemonicToByteArray, METH_VARARGS, NULL}, + { (char *)"SKY_bip39_IsMnemonicValid", _wrap_SKY_bip39_IsMnemonicValid, METH_VARARGS, NULL}, { (char *)"SKY_httphelper_Address_UnmarshalJSON", _wrap_SKY_httphelper_Address_UnmarshalJSON, METH_VARARGS, NULL}, { (char *)"SKY_httphelper_Address_MarshalJSON", _wrap_SKY_httphelper_Address_MarshalJSON, METH_VARARGS, NULL}, { (char *)"SKY_httphelper_Coins_UnmarshalJSON", _wrap_SKY_httphelper_Coins_UnmarshalJSON, METH_VARARGS, NULL}, @@ -28207,28 +28368,35 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_httphelper_Hours_UnmarshalJSON", _wrap_SKY_httphelper_Hours_UnmarshalJSON, METH_VARARGS, NULL}, { (char *)"SKY_httphelper_Hours_MarshalJSON", _wrap_SKY_httphelper_Hours_MarshalJSON, METH_VARARGS, NULL}, { (char *)"SKY_httphelper_Hours_Value", _wrap_SKY_httphelper_Hours_Value, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_NewClient", _wrap_SKY_webrpc_NewClient, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_CSRF", _wrap_SKY_webrpc_Client_CSRF, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_InjectTransaction", _wrap_SKY_webrpc_Client_InjectTransaction, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetStatus", _wrap_SKY_webrpc_Client_GetStatus, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetTransactionByID", _wrap_SKY_webrpc_Client_GetTransactionByID, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetAddressUxOuts", _wrap_SKY_webrpc_Client_GetAddressUxOuts, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetBlocksInRange", _wrap_SKY_webrpc_Client_GetBlocksInRange, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetBlocksBySeq", _wrap_SKY_webrpc_Client_GetBlocksBySeq, METH_VARARGS, NULL}, + { (char *)"SKY_webrpc_Client_GetLastBlocks", _wrap_SKY_webrpc_Client_GetLastBlocks, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_CreateOptionsHandle", _wrap_SKY_wallet_CreateOptionsHandle, METH_VARARGS, NULL}, + { (char *)"SKY_cli_App_Run", _wrap_SKY_cli_App_Run, METH_VARARGS, NULL}, + { (char *)"SKY_cli_Config_GetCoin", _wrap_SKY_cli_Config_GetCoin, METH_VARARGS, NULL}, + { (char *)"SKY_cli_Config_GetRPCAddress", _wrap_SKY_cli_Config_GetRPCAddress, METH_VARARGS, NULL}, + { (char *)"SKY_cli_RPCClientFromApp", _wrap_SKY_cli_RPCClientFromApp, METH_VARARGS, NULL}, + { (char *)"SKY_cli_Getenv", _wrap_SKY_cli_Getenv, METH_VARARGS, NULL}, + { (char *)"SKY_cli_Setenv", _wrap_SKY_cli_Setenv, METH_VARARGS, NULL}, { (char *)"SKY_wallet_NewBalance", _wrap_SKY_wallet_NewBalance, METH_VARARGS, NULL}, { (char *)"SKY_wallet_NewBalanceFromUxOut", _wrap_SKY_wallet_NewBalanceFromUxOut, METH_VARARGS, NULL}, { (char *)"SKY_wallet_Balance_Add", _wrap_SKY_wallet_Balance_Add, METH_VARARGS, NULL}, { (char *)"SKY_wallet_Balance_Sub", _wrap_SKY_wallet_Balance_Sub, METH_VARARGS, NULL}, { (char *)"SKY_wallet_Balance_Equals", _wrap_SKY_wallet_Balance_Equals, METH_VARARGS, NULL}, { (char *)"SKY_wallet_Balance_IsZero", _wrap_SKY_wallet_Balance_IsZero, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_CryptoTypeFromString", _wrap_SKY_wallet_CryptoTypeFromString, METH_VARARGS, NULL}, - { (char *)"SKY_cli_AddPrivateKey", _wrap_SKY_cli_AddPrivateKey, METH_VARARGS, NULL}, - { (char *)"SKY_cli_AddPrivateKeyToFile", _wrap_SKY_cli_AddPrivateKeyToFile, METH_VARARGS, NULL}, - { (char *)"SKY_api_NewCreateTransactionResponse", _wrap_SKY_api_NewCreateTransactionResponse, METH_VARARGS, NULL}, - { (char *)"SKY_api_NewCreatedTransaction", _wrap_SKY_api_NewCreatedTransaction, METH_VARARGS, NULL}, - { (char *)"SKY_api_CreatedTransaction_ToTransaction", _wrap_SKY_api_CreatedTransaction_ToTransaction, METH_VARARGS, NULL}, - { (char *)"SKY_api_NewCreatedTransactionOutput", _wrap_SKY_api_NewCreatedTransactionOutput, METH_VARARGS, NULL}, - { (char *)"SKY_api_NewCreatedTransactionInput", _wrap_SKY_api_NewCreatedTransactionInput, METH_VARARGS, NULL}, - { (char *)"SKY_logging_EnableColors", _wrap_SKY_logging_EnableColors, METH_VARARGS, NULL}, - { (char *)"SKY_logging_DisableColors", _wrap_SKY_logging_DisableColors, METH_VARARGS, NULL}, - { (char *)"SKY_logging_Disable", _wrap_SKY_logging_Disable, METH_VARARGS, NULL}, - { (char *)"SKY_file_InitDataDir", _wrap_SKY_file_InitDataDir, METH_VARARGS, NULL}, - { (char *)"SKY_file_UserHome", _wrap_SKY_file_UserHome, METH_VARARGS, NULL}, - { (char *)"SKY_file_ResolveResourceDirectory", _wrap_SKY_file_ResolveResourceDirectory, METH_VARARGS, NULL}, - { (char *)"SKY_file_DetermineResourcePath", _wrap_SKY_file_DetermineResourcePath, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_CreateOptionsHandle", _wrap_SKY_wallet_CreateOptionsHandle, METH_VARARGS, NULL}, + { (char *)"SKY_droplet_FromString", _wrap_SKY_droplet_FromString, METH_VARARGS, NULL}, + { (char *)"SKY_droplet_ToString", _wrap_SKY_droplet_ToString, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_NewReadableEntry", _wrap_SKY_wallet_NewReadableEntry, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_LoadReadableWallet", _wrap_SKY_wallet_LoadReadableWallet, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_ReadableWallet_Save", _wrap_SKY_wallet_ReadableWallet_Save, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_ReadableWallet_Load", _wrap_SKY_wallet_ReadableWallet_Load, METH_VARARGS, NULL}, + { (char *)"SKY_wallet_ReadableWallet_Erase", _wrap_SKY_wallet_ReadableWallet_Erase, METH_VARARGS, NULL}, { (char *)"SKY_cli_LoadConfig", _wrap_SKY_cli_LoadConfig, METH_VARARGS, NULL}, { (char *)"SKY_cli_Config_FullWalletPath", _wrap_SKY_cli_Config_FullWalletPath, METH_VARARGS, NULL}, { (char *)"SKY_cli_Config_FullDBPath", _wrap_SKY_cli_Config_FullDBPath, METH_VARARGS, NULL}, @@ -28261,44 +28429,6 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_coin_AddressUxOuts_GetOutputLength", _wrap_SKY_coin_AddressUxOuts_GetOutputLength, METH_VARARGS, NULL}, { (char *)"SKY_coin_AddressUxOuts_Length", _wrap_SKY_coin_AddressUxOuts_Length, METH_VARARGS, NULL}, { (char *)"SKY_coin_AddressUxOuts_Set", _wrap_SKY_coin_AddressUxOuts_Set, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_RandByte", _wrap_SKY_cipher_RandByte, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_NewPubKey", _wrap_SKY_cipher_NewPubKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKeyFromHex", _wrap_SKY_cipher_PubKeyFromHex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKeyFromSecKey", _wrap_SKY_cipher_PubKeyFromSecKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKeyFromSig", _wrap_SKY_cipher_PubKeyFromSig, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKey_Verify", _wrap_SKY_cipher_PubKey_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKey_Hex", _wrap_SKY_cipher_PubKey_Hex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_PubKeyRipemd160", _wrap_SKY_cipher_PubKeyRipemd160, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_NewSecKey", _wrap_SKY_cipher_NewSecKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SecKeyFromHex", _wrap_SKY_cipher_SecKeyFromHex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SecKey_Verify", _wrap_SKY_cipher_SecKey_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SecKey_Hex", _wrap_SKY_cipher_SecKey_Hex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_ECDH", _wrap_SKY_cipher_ECDH, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_NewSig", _wrap_SKY_cipher_NewSig, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SigFromHex", _wrap_SKY_cipher_SigFromHex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Sig_Hex", _wrap_SKY_cipher_Sig_Hex, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SignHash", _wrap_SKY_cipher_SignHash, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_VerifyAddressSignedHash", _wrap_SKY_cipher_VerifyAddressSignedHash, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_VerifySignedHash", _wrap_SKY_cipher_VerifySignedHash, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_VerifyPubKeySignedHash", _wrap_SKY_cipher_VerifyPubKeySignedHash, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_GenerateKeyPair", _wrap_SKY_cipher_GenerateKeyPair, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_GenerateDeterministicKeyPair", _wrap_SKY_cipher_GenerateDeterministicKeyPair, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_DeterministicKeyPairIterator", _wrap_SKY_cipher_DeterministicKeyPairIterator, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_GenerateDeterministicKeyPairs", _wrap_SKY_cipher_GenerateDeterministicKeyPairs, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_GenerateDeterministicKeyPairsSeed", _wrap_SKY_cipher_GenerateDeterministicKeyPairsSeed, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_CheckSecKey", _wrap_SKY_cipher_CheckSecKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_CheckSecKeyHash", _wrap_SKY_cipher_CheckSecKeyHash, METH_VARARGS, NULL}, - { (char *)"SKY_droplet_FromString", _wrap_SKY_droplet_FromString, METH_VARARGS, NULL}, - { (char *)"SKY_droplet_ToString", _wrap_SKY_droplet_ToString, METH_VARARGS, NULL}, - { (char *)"SKY_handle_close", _wrap_SKY_handle_close, METH_VARARGS, NULL}, - { (char *)"SKY_handle_copy", _wrap_SKY_handle_copy, METH_VARARGS, NULL}, - { (char *)"SKY_fee_VerifyTransactionFee", _wrap_SKY_fee_VerifyTransactionFee, METH_VARARGS, NULL}, - { (char *)"SKY_fee_VerifyTransactionFeeForHours", _wrap_SKY_fee_VerifyTransactionFeeForHours, METH_VARARGS, NULL}, - { (char *)"SKY_fee_RequiredFee", _wrap_SKY_fee_RequiredFee, METH_VARARGS, NULL}, - { (char *)"SKY_fee_RemainingHours", _wrap_SKY_fee_RemainingHours, METH_VARARGS, NULL}, - { (char *)"SKY_fee_TransactionFee", _wrap_SKY_fee_TransactionFee, METH_VARARGS, NULL}, - { (char *)"SKY_encrypt_ScryptChacha20poly1305_Encrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Encrypt, METH_VARARGS, NULL}, - { (char *)"SKY_encrypt_ScryptChacha20poly1305_Decrypt", _wrap_SKY_encrypt_ScryptChacha20poly1305_Decrypt, METH_VARARGS, NULL}, { (char *)"SKY_api_NewClient", _wrap_SKY_api_NewClient, METH_VARARGS, NULL}, { (char *)"SKY_api_Client_CSRF", _wrap_SKY_api_Client_CSRF, METH_VARARGS, NULL}, { (char *)"SKY_api_Client_Version", _wrap_SKY_api_Client_Version, METH_VARARGS, NULL}, @@ -28347,127 +28477,17 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_api_Client_Health", _wrap_SKY_api_Client_Health, METH_VARARGS, NULL}, { (char *)"SKY_api_Client_EncryptWallet", _wrap_SKY_api_Client_EncryptWallet, METH_VARARGS, NULL}, { (char *)"SKY_api_Client_DecryptWallet", _wrap_SKY_api_Client_DecryptWallet, METH_VARARGS, NULL}, - { (char *)"SKY_map_Get", _wrap_SKY_map_Get, METH_VARARGS, NULL}, - { (char *)"SKY_map_HasKey", _wrap_SKY_map_HasKey, METH_VARARGS, NULL}, - { (char *)"SKY_map_Close", _wrap_SKY_map_Close, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_NewError", _wrap_SKY_wallet_NewError, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_NewWallet", _wrap_SKY_wallet_NewWallet, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Lock", _wrap_SKY_wallet_Wallet_Lock, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Unlock", _wrap_SKY_wallet_Wallet_Unlock, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Load", _wrap_SKY_wallet_Load, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Save", _wrap_SKY_wallet_Wallet_Save, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Validate", _wrap_SKY_wallet_Wallet_Validate, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Type", _wrap_SKY_wallet_Wallet_Type, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Version", _wrap_SKY_wallet_Wallet_Version, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Filename", _wrap_SKY_wallet_Wallet_Filename, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_Label", _wrap_SKY_wallet_Wallet_Label, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_IsEncrypted", _wrap_SKY_wallet_Wallet_IsEncrypted, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_GenerateAddresses", _wrap_SKY_wallet_Wallet_GenerateAddresses, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_GetAddresses", _wrap_SKY_wallet_Wallet_GetAddresses, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_GetEntry", _wrap_SKY_wallet_Wallet_GetEntry, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Wallet_AddEntry", _wrap_SKY_wallet_Wallet_AddEntry, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_DistributeSpendHours", _wrap_SKY_wallet_DistributeSpendHours, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_DistributeCoinHoursProportional", _wrap_SKY_wallet_DistributeCoinHoursProportional, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_NewUxBalances", _wrap_SKY_wallet_NewUxBalances, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_NewUxBalance", _wrap_SKY_wallet_NewUxBalance, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_ChooseSpendsMinimizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMinimizeUxOuts, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_ChooseSpendsMaximizeUxOuts", _wrap_SKY_wallet_ChooseSpendsMaximizeUxOuts, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_DecodeBase58BitcoinAddress", _wrap_SKY_cipher_DecodeBase58BitcoinAddress, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddressFromPubKey", _wrap_SKY_cipher_BitcoinAddressFromPubKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddressFromSecKey", _wrap_SKY_cipher_BitcoinAddressFromSecKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinWalletImportFormatFromSeckey", _wrap_SKY_cipher_BitcoinWalletImportFormatFromSeckey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddressFromBytes", _wrap_SKY_cipher_BitcoinAddressFromBytes, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_SecKeyFromBitcoinWalletImportFormat", _wrap_SKY_cipher_SecKeyFromBitcoinWalletImportFormat, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddress_Null", _wrap_SKY_cipher_BitcoinAddress_Null, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddress_Bytes", _wrap_SKY_cipher_BitcoinAddress_Bytes, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddress_Verify", _wrap_SKY_cipher_BitcoinAddress_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddress_String", _wrap_SKY_cipher_BitcoinAddress_String, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_BitcoinAddress_Checksum", _wrap_SKY_cipher_BitcoinAddress_Checksum, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Create_Transaction", _wrap_SKY_coin_Create_Transaction, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_Copy", _wrap_SKY_coin_Transaction_Copy, METH_VARARGS, NULL}, - { (char *)"SKY_coin_GetTransactionObject", _wrap_SKY_coin_GetTransactionObject, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_ResetInputs", _wrap_SKY_coin_Transaction_ResetInputs, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetInputsCount", _wrap_SKY_coin_Transaction_GetInputsCount, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetInputAt", _wrap_SKY_coin_Transaction_GetInputAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_SetInputAt", _wrap_SKY_coin_Transaction_SetInputAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetOutputsCount", _wrap_SKY_coin_Transaction_GetOutputsCount, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetOutputAt", _wrap_SKY_coin_Transaction_GetOutputAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_SetOutputAt", _wrap_SKY_coin_Transaction_SetOutputAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetSignaturesCount", _wrap_SKY_coin_Transaction_GetSignaturesCount, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_GetSignatureAt", _wrap_SKY_coin_Transaction_GetSignatureAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_SetSignatureAt", _wrap_SKY_coin_Transaction_SetSignatureAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_PushSignature", _wrap_SKY_coin_Transaction_PushSignature, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_ResetOutputs", _wrap_SKY_coin_Transaction_ResetOutputs, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_ResetSignatures", _wrap_SKY_coin_Transaction_ResetSignatures, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_Verify", _wrap_SKY_coin_Transaction_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_VerifyInput", _wrap_SKY_coin_Transaction_VerifyInput, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_PushInput", _wrap_SKY_coin_Transaction_PushInput, METH_VARARGS, NULL}, - { (char *)"SKY_coin_TransactionOutput_UxID", _wrap_SKY_coin_TransactionOutput_UxID, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_PushOutput", _wrap_SKY_coin_Transaction_PushOutput, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_SignInputs", _wrap_SKY_coin_Transaction_SignInputs, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_Size", _wrap_SKY_coin_Transaction_Size, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_Hash", _wrap_SKY_coin_Transaction_Hash, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_SizeHash", _wrap_SKY_coin_Transaction_SizeHash, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_TxID", _wrap_SKY_coin_Transaction_TxID, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_TxIDHex", _wrap_SKY_coin_Transaction_TxIDHex, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_UpdateHeader", _wrap_SKY_coin_Transaction_UpdateHeader, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_HashInner", _wrap_SKY_coin_Transaction_HashInner, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_Serialize", _wrap_SKY_coin_Transaction_Serialize, METH_VARARGS, NULL}, - { (char *)"SKY_coin_TransactionDeserialize", _wrap_SKY_coin_TransactionDeserialize, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transaction_OutputHours", _wrap_SKY_coin_Transaction_OutputHours, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Create_Transactions", _wrap_SKY_coin_Create_Transactions, METH_VARARGS, NULL}, - { (char *)"SKY_coin_GetTransactionsObject", _wrap_SKY_coin_GetTransactionsObject, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_Length", _wrap_SKY_coin_Transactions_Length, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_Add", _wrap_SKY_coin_Transactions_Add, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_Fees", _wrap_SKY_coin_Transactions_Fees, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_GetAt", _wrap_SKY_coin_Transactions_GetAt, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_Hashes", _wrap_SKY_coin_Transactions_Hashes, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_Size", _wrap_SKY_coin_Transactions_Size, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Transactions_TruncateBytesTo", _wrap_SKY_coin_Transactions_TruncateBytesTo, METH_VARARGS, NULL}, - { (char *)"SKY_coin_SortTransactions", _wrap_SKY_coin_SortTransactions, METH_VARARGS, NULL}, - { (char *)"SKY_coin_NewSortableTransactions", _wrap_SKY_coin_NewSortableTransactions, METH_VARARGS, NULL}, - { (char *)"SKY_coin_SortableTransactions_Sort", _wrap_SKY_coin_SortableTransactions_Sort, METH_VARARGS, NULL}, - { (char *)"SKY_coin_SortableTransactions_Len", _wrap_SKY_coin_SortableTransactions_Len, METH_VARARGS, NULL}, - { (char *)"SKY_coin_SortableTransactions_Less", _wrap_SKY_coin_SortableTransactions_Less, METH_VARARGS, NULL}, - { (char *)"SKY_coin_SortableTransactions_Swap", _wrap_SKY_coin_SortableTransactions_Swap, METH_VARARGS, NULL}, - { (char *)"SKY_coin_VerifyTransactionCoinsSpending", _wrap_SKY_coin_VerifyTransactionCoinsSpending, METH_VARARGS, NULL}, - { (char *)"SKY_coin_VerifyTransactionHoursSpending", _wrap_SKY_coin_VerifyTransactionHoursSpending, METH_VARARGS, NULL}, - { (char *)"SKY_cli_GenerateWallet", _wrap_SKY_cli_GenerateWallet, METH_VARARGS, NULL}, - { (char *)"SKY_cli_MakeAlphanumericSeed", _wrap_SKY_cli_MakeAlphanumericSeed, METH_VARARGS, NULL}, - { (char *)"SKY_cli_GetWalletOutputsFromFile", _wrap_SKY_cli_GetWalletOutputsFromFile, METH_VARARGS, NULL}, - { (char *)"SKY_cli_GetWalletOutputs", _wrap_SKY_cli_GetWalletOutputs, METH_VARARGS, NULL}, - { (char *)"SKY_cli_CheckWalletBalance", _wrap_SKY_cli_CheckWalletBalance, METH_VARARGS, NULL}, - { (char *)"SKY_cli_GetBalanceOfAddresses", _wrap_SKY_cli_GetBalanceOfAddresses, METH_VARARGS, NULL}, - { (char *)"SKY_cli_App_Run", _wrap_SKY_cli_App_Run, METH_VARARGS, NULL}, - { (char *)"SKY_cli_Config_GetCoin", _wrap_SKY_cli_Config_GetCoin, METH_VARARGS, NULL}, - { (char *)"SKY_cli_Config_GetRPCAddress", _wrap_SKY_cli_Config_GetRPCAddress, METH_VARARGS, NULL}, - { (char *)"SKY_cli_RPCClientFromApp", _wrap_SKY_cli_RPCClientFromApp, METH_VARARGS, NULL}, - { (char *)"SKY_cli_Getenv", _wrap_SKY_cli_Getenv, METH_VARARGS, NULL}, - { (char *)"SKY_cli_Setenv", _wrap_SKY_cli_Setenv, METH_VARARGS, NULL}, - { (char *)"SKY_coin_AddUint64", _wrap_SKY_coin_AddUint64, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Uint64ToInt64", _wrap_SKY_coin_Uint64ToInt64, METH_VARARGS, NULL}, - { (char *)"SKY_coin_Int64ToUint64", _wrap_SKY_coin_Int64ToUint64, METH_VARARGS, NULL}, - { (char *)"SKY_coin_IntToUint32", _wrap_SKY_coin_IntToUint32, METH_VARARGS, NULL}, - { (char *)"SKY_iputil_LocalhostIP", _wrap_SKY_iputil_LocalhostIP, METH_VARARGS, NULL}, - { (char *)"SKY_iputil_IsLocalhost", _wrap_SKY_iputil_IsLocalhost, METH_VARARGS, NULL}, - { (char *)"SKY_iputil_SplitAddr", _wrap_SKY_iputil_SplitAddr, METH_VARARGS, NULL}, - { (char *)"SKY_certutil_NewTLSCertPair", _wrap_SKY_certutil_NewTLSCertPair, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_DecodeBase58Address", _wrap_SKY_cipher_DecodeBase58Address, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_AddressFromBytes", _wrap_SKY_cipher_AddressFromBytes, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_AddressFromPubKey", _wrap_SKY_cipher_AddressFromPubKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_AddressFromSecKey", _wrap_SKY_cipher_AddressFromSecKey, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Address_Null", _wrap_SKY_cipher_Address_Null, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Address_Bytes", _wrap_SKY_cipher_Address_Bytes, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Address_Verify", _wrap_SKY_cipher_Address_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Address_String", _wrap_SKY_cipher_Address_String, METH_VARARGS, NULL}, - { (char *)"SKY_cipher_Address_Checksum", _wrap_SKY_cipher_Address_Checksum, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_NewReadableEntry", _wrap_SKY_wallet_NewReadableEntry, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_LoadReadableWallet", _wrap_SKY_wallet_LoadReadableWallet, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_ReadableWallet_Save", _wrap_SKY_wallet_ReadableWallet_Save, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_ReadableWallet_Load", _wrap_SKY_wallet_ReadableWallet_Load, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_ReadableWallet_Erase", _wrap_SKY_wallet_ReadableWallet_Erase, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Entry_Verify", _wrap_SKY_wallet_Entry_Verify, METH_VARARGS, NULL}, - { (char *)"SKY_wallet_Entry_VerifyPublic", _wrap_SKY_wallet_Entry_VerifyPublic, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Ripemd160_Set", _wrap_SKY_cipher_Ripemd160_Set, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_HashRipemd160", _wrap_SKY_cipher_HashRipemd160, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SHA256_Set", _wrap_SKY_cipher_SHA256_Set, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SHA256_Hex", _wrap_SKY_cipher_SHA256_Hex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SHA256_Xor", _wrap_SKY_cipher_SHA256_Xor, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SumSHA256", _wrap_SKY_cipher_SumSHA256, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SHA256FromHex", _wrap_SKY_cipher_SHA256FromHex, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_DoubleSHA256", _wrap_SKY_cipher_DoubleSHA256, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_AddSHA256", _wrap_SKY_cipher_AddSHA256, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_Merkle", _wrap_SKY_cipher_Merkle, METH_VARARGS, NULL}, + { (char *)"SKY_cipher_SHA256_Null", _wrap_SKY_cipher_SHA256_Null, METH_VARARGS, NULL}, { (char *)"SKY_JsonEncode_Handle", _wrap_SKY_JsonEncode_Handle, METH_VARARGS, NULL}, { (char *)"SKY_Handle_Progress_GetCurrent", _wrap_SKY_Handle_Progress_GetCurrent, METH_VARARGS, NULL}, { (char *)"SKY_Handle_Block_GetHeadSeq", _wrap_SKY_Handle_Block_GetHeadSeq, METH_VARARGS, NULL}, @@ -28496,29 +28516,9 @@ static PyMethodDef SwigMethods[] = { { (char *)"SKY_api_Handle_GetWalletSeed", _wrap_SKY_api_Handle_GetWalletSeed, METH_VARARGS, NULL}, { (char *)"SKY_api_Handle_GetWalletLastSeed", _wrap_SKY_api_Handle_GetWalletLastSeed, METH_VARARGS, NULL}, { (char *)"SKY_api_Handle_GetBuildInfoData", _wrap_SKY_api_Handle_GetBuildInfoData, METH_VARARGS, NULL}, - { (char *)"SKY_api_NewWalletResponse", _wrap_SKY_api_NewWalletResponse, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_NewClient", _wrap_SKY_webrpc_NewClient, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_CSRF", _wrap_SKY_webrpc_Client_CSRF, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_InjectTransaction", _wrap_SKY_webrpc_Client_InjectTransaction, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetStatus", _wrap_SKY_webrpc_Client_GetStatus, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetTransactionByID", _wrap_SKY_webrpc_Client_GetTransactionByID, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetAddressUxOuts", _wrap_SKY_webrpc_Client_GetAddressUxOuts, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetBlocksInRange", _wrap_SKY_webrpc_Client_GetBlocksInRange, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetBlocksBySeq", _wrap_SKY_webrpc_Client_GetBlocksBySeq, METH_VARARGS, NULL}, - { (char *)"SKY_webrpc_Client_GetLastBlocks", _wrap_SKY_webrpc_Client_GetLastBlocks, METH_VARARGS, NULL}, - { (char *)"SKY_bip39_NewDefaultMnemomic", _wrap_SKY_bip39_NewDefaultMnemomic, METH_VARARGS, NULL}, - { (char *)"SKY_bip39_NewEntropy", _wrap_SKY_bip39_NewEntropy, METH_VARARGS, NULL}, - { (char *)"SKY_bip39_NewMnemonic", _wrap_SKY_bip39_NewMnemonic, METH_VARARGS, NULL}, - { (char *)"SKY_bip39_MnemonicToByteArray", _wrap_SKY_bip39_MnemonicToByteArray, METH_VARARGS, NULL}, - { (char *)"SKY_bip39_IsMnemonicValid", _wrap_SKY_bip39_IsMnemonicValid, METH_VARARGS, NULL}, - { (char *)"SKY_cli_CreateRawTxFromWallet", _wrap_SKY_cli_CreateRawTxFromWallet, METH_VARARGS, NULL}, - { (char *)"SKY_cli_CreateRawTxFromAddress", _wrap_SKY_cli_CreateRawTxFromAddress, METH_VARARGS, NULL}, - { (char *)"SKY_cli_CreateRawTx", _wrap_SKY_cli_CreateRawTx, METH_VARARGS, NULL}, - { (char *)"SKY_cli_NewTransaction", _wrap_SKY_cli_NewTransaction, METH_VARARGS, NULL}, - { (char *)"SKY_testutil_MakeAddress", _wrap_SKY_testutil_MakeAddress, METH_VARARGS, NULL}, - { (char *)"SKY_apputil_CatchInterruptPanic", _wrap_SKY_apputil_CatchInterruptPanic, METH_VARARGS, NULL}, - { (char *)"SKY_apputil_CatchDebug", _wrap_SKY_apputil_CatchDebug, METH_VARARGS, NULL}, - { (char *)"SKY_apputil_PrintProgramStatus", _wrap_SKY_apputil_PrintProgramStatus, METH_VARARGS, NULL}, + { (char *)"SKY_logging_EnableColors", _wrap_SKY_logging_EnableColors, METH_VARARGS, NULL}, + { (char *)"SKY_logging_DisableColors", _wrap_SKY_logging_DisableColors, METH_VARARGS, NULL}, + { (char *)"SKY_logging_Disable", _wrap_SKY_logging_Disable, METH_VARARGS, NULL}, { (char *)"api__RichlistParams_N_set", _wrap_api__RichlistParams_N_set, METH_VARARGS, NULL}, { (char *)"api__RichlistParams_N_get", _wrap_api__RichlistParams_N_get, METH_VARARGS, NULL}, { (char *)"api__RichlistParams_IncludeDistribution_set", _wrap_api__RichlistParams_IncludeDistribution_set, METH_VARARGS, NULL}, diff --git a/tests/restapi/test_build_info.py b/tests/restapi/test_build_info.py deleted file mode 100644 index a53da0ca..00000000 --- a/tests/restapi/test_build_info.py +++ /dev/null @@ -1,39 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import unittest - -import swagger_client -from swagger_client.models.build_info import BuildInfo # noqa: E501 -from swagger_client.rest import ApiException - - -class TestBuildInfo(unittest.TestCase): - """BuildInfo unit test stubs""" - - def setUp(self): - pass - - def tearDown(self): - pass - - def testBuildInfo(self): - """Test BuildInfo""" - # FIXME: construct object with mandatory attributes with example values - # model = swagger_client.models.build_info.BuildInfo() # noqa: E501 - pass - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/restapi/test_default_api.py b/tests/restapi/test_default_api.py deleted file mode 100644 index 81cfd033..00000000 --- a/tests/restapi/test_default_api.py +++ /dev/null @@ -1,64 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import unittest - -import swagger_client -from swagger_client.api.default_api import DefaultApi # noqa: E501 -from swagger_client.rest import ApiException - - -class TestDefaultApi(unittest.TestCase): - """DefaultApi unit test stubs""" - - def setUp(self): - self.api = swagger_client.api.default_api.DefaultApi() # noqa: E501 - - def tearDown(self): - pass - - def test_coin_supply(self): - """Test case for coin_supply - - """ - pass - - def test_csrf_token(self): - """Test case for csrf_token - - Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 - """ - pass - - def test_resend_unconfirmed_txns(self): - """Test case for resend_unconfirmed_txns - - """ - pass - - def test_version(self): - """Test case for version - - """ - pass - - def test_wallet_folder(self): - """Test case for wallet_folder - - """ - pass - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/restapi/test_inline_response_200.py b/tests/restapi/test_inline_response_200.py deleted file mode 100644 index 2ace8516..00000000 --- a/tests/restapi/test_inline_response_200.py +++ /dev/null @@ -1,39 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import unittest - -import swagger_client -from swagger_client.models.inline_response_200 import InlineResponse200 # noqa: E501 -from swagger_client.rest import ApiException - - -class TestInlineResponse200(unittest.TestCase): - """InlineResponse200 unit test stubs""" - - def setUp(self): - pass - - def tearDown(self): - pass - - def testInlineResponse200(self): - """Test InlineResponse200""" - # FIXME: construct object with mandatory attributes with example values - # model = swagger_client.models.inline_response_200.InlineResponse200() # noqa: E501 - pass - - -if __name__ == '__main__': - unittest.main() diff --git a/tests/restapi/test_inline_response_422.py b/tests/restapi/test_inline_response_422.py deleted file mode 100644 index 8399fb5e..00000000 --- a/tests/restapi/test_inline_response_422.py +++ /dev/null @@ -1,39 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import unittest - -import swagger_client -from swagger_client.models.inline_response_422 import InlineResponse422 # noqa: E501 -from swagger_client.rest import ApiException - - -class TestInlineResponse422(unittest.TestCase): - """InlineResponse422 unit test stubs""" - - def setUp(self): - pass - - def tearDown(self): - pass - - def testInlineResponse422(self): - """Test InlineResponse422""" - # FIXME: construct object with mandatory attributes with example values - # model = swagger_client.models.inline_response_422.InlineResponse422() # noqa: E501 - pass - - -if __name__ == '__main__': - unittest.main() From fc9850b94ca51958efa3631ff3d2f0b09fda4905 Mon Sep 17 00:00:00 2001 From: Marcos Maceo Date: Tue, 12 Mar 2019 19:35:18 -0400 Subject: [PATCH 6/7] [pyrest] refs #86 Set Makefile and .travis for pysky_api --- .travis/install-linux.sh | 2 ++ Makefile | 11 ++++++++--- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/.travis/install-linux.sh b/.travis/install-linux.sh index 1cb68edf..dbbd0105 100644 --- a/.travis/install-linux.sh +++ b/.travis/install-linux.sh @@ -18,6 +18,8 @@ chmod +x "$HOME/bin/gimme" # Install Python libraries $PIP install --upgrade pip setuptools tox-travis $PIP install -r "$REPO_ROOT/requirements.dev.txt" +$PIP install -r "$REPO_ROOT/pysky_api/requirements.txt" +$PIP install -r "$REPO_ROOT/pysky_api/test-requirements.txt" # Compile SWIG mkdir swig_build && \ diff --git a/Makefile b/Makefile index 8aa44b86..d477d260 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ .DEFAULT_GOAL := help -.PHONY: configure build-libc build-swig develop build-libc-swig build +.PHONY: configure build-libc build-swig develop build-libc-swig build build-pysky_api .PHONY: test test-ci help # Compilation output @@ -25,8 +25,7 @@ SRC_FILES = $(shell find $(SKYCOIN_DIR)/src -type f -name "*.go") SWIG_FILES = $(shell find $(LIBSWIG_DIR) -type f -name "*.i") HEADER_FILES = $(shell find $(SKYCOIN_DIR)/include -type f -name "*.h") -SWAGGER_SPEC_DIR = get in some way swagger spec route -PYTHON_CLIENT_DIR = url python client +PYTHON_CLIENT_DIR = pysky_api ifeq ($(shell uname -s),Linux) TEMP_DIR = tmp @@ -74,23 +73,29 @@ build-swig: ## Generate Python C module from SWIG interfaces develop: ## Install PySkycoin for development $(PYTHON_BIN) setup.py develop + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py develop) build-libc-swig: build-libc build-swig build: build-libc-swig ## Build PySkycoin Python package $(PYTHON_BIN) setup.py build + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py build) test-ci: ## Run tests on (Travis) CI build tox + (cd $(PYTHON_CLIENT_DIR) && tox) test: build-libc build-swig develop ## Run project test suite $(PYTHON_BIN) setup.py test + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py test) sdist: ## Create source distribution archive $(PYTHON_BIN) setup.py sdist --formats=gztar + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py sdist --formats=gztar) bdist_wheel: ## Create architecture-specific binary wheel distribution archive $(PYTHON_BIN) setup.py bdist_wheel + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py bdist_wheel) # FIXME: After libskycoin 32-bits binaries add bdist_manylinux_i686 bdist_manylinux: bdist_manylinux_amd64 ## Create multilinux binary wheel distribution archives From 8f8d7d42aeedddd5a7386101e8bb25bd3f99af3f Mon Sep 17 00:00:00 2001 From: Marcos Maceo Date: Tue, 12 Mar 2019 20:55:39 -0400 Subject: [PATCH 7/7] [restsharp] refs #86 Solving requested changes for PR --- .travis/install-linux.sh | 4 +- Makefile | 31 +- {pysky_api => skyapi}/.gitignore | 0 .../.openapi-generator-ignore | 0 .../.openapi-generator/VERSION | 0 {pysky_api => skyapi}/.travis.yml | 0 {pysky_api => skyapi}/README.md | 0 .../docs/Apiv1exploreraddressInputs.md | 0 .../docs/Apiv1exploreraddressOutputs.md | 0 .../docs/Apiv1exploreraddressStatus.md | 0 .../docs/Apiv1pendingTxsTransaction.md | 0 .../docs/Apiv1walletsEntries.md | 0 .../docs/Apiv1walletsMeta.md | 0 .../Apiv1wallettransactionHoursSelection.md | 0 .../docs/Apiv1wallettransactionTo.md | 0 .../docs/Apiv1wallettransactionWallet.md | 0 {pysky_api => skyapi}/docs/DefaultApi.md | 0 {pysky_api => skyapi}/docs/InlineObject.md | 0 .../docs/InlineResponse200.md | 0 .../docs/InlineResponse2001.md | 0 .../docs/InlineResponse2002.md | 0 .../docs/InlineResponse2003.md | 0 ...esponse2003UnconfirmedVerifyTransaction.md | 0 .../docs/InlineResponse2004.md | 0 .../docs/InlineResponse2005.md | 0 .../docs/InlineResponse2006.md | 0 .../docs/InlineResponse2007.md | 0 .../docs/InlineResponse2007Data.md | 0 .../docs/InlineResponseDefault.md | 0 {pysky_api => skyapi}/git_push.sh | 0 .../openapi_client/__init__.py | 0 .../openapi_client/api/__init__.py | 0 .../openapi_client/api/default_api.py | 0 .../openapi_client/api_client.py | 0 .../openapi_client/configuration.py | 0 .../openapi_client/models/__init__.py | 0 .../models/apiv1exploreraddress_inputs.py | 0 .../models/apiv1exploreraddress_outputs.py | 0 .../models/apiv1exploreraddress_status.py | 0 .../models/apiv1pending_txs_transaction.py | 0 .../models/apiv1wallets_entries.py | 0 .../models/apiv1wallets_meta.py | 0 .../apiv1wallettransaction_hours_selection.py | 0 .../models/apiv1wallettransaction_to.py | 0 .../models/apiv1wallettransaction_wallet.py | 0 .../openapi_client/models/inline_object.py | 0 .../models/inline_response200.py | 0 .../models/inline_response2001.py | 0 .../models/inline_response2002.py | 0 .../models/inline_response2003.py | 0 ...onse2003_unconfirmed_verify_transaction.py | 0 .../models/inline_response2004.py | 0 .../models/inline_response2005.py | 0 .../models/inline_response2006.py | 0 .../models/inline_response2007.py | 0 .../models/inline_response2007_data.py | 0 .../models/inline_response_default.py | 0 {pysky_api => skyapi}/openapi_client/rest.py | 0 {pysky_api => skyapi}/requirements.txt | 0 {pysky_api => skyapi}/setup.py | 0 {pysky_api => skyapi}/test-requirements.txt | 0 {pysky_api => skyapi}/test/__init__.py | 0 .../test/test_apiv1exploreraddress_inputs.py | 0 .../test/test_apiv1exploreraddress_outputs.py | 0 .../test/test_apiv1exploreraddress_status.py | 0 .../test/test_apiv1pending_txs_transaction.py | 0 .../test/test_apiv1wallets_entries.py | 0 .../test/test_apiv1wallets_meta.py | 0 ..._apiv1wallettransaction_hours_selection.py | 0 .../test/test_apiv1wallettransaction_to.py | 0 .../test_apiv1wallettransaction_wallet.py | 0 .../test/test_default_api.py | 0 .../test/test_inline_object.py | 0 .../test/test_inline_response200.py | 0 .../test/test_inline_response2001.py | 0 .../test/test_inline_response2002.py | 0 .../test/test_inline_response2003.py | 0 ...onse2003_unconfirmed_verify_transaction.py | 0 .../test/test_inline_response2004.py | 0 .../test/test_inline_response2005.py | 0 .../test/test_inline_response2006.py | 0 .../test/test_inline_response2007.py | 0 .../test/test_inline_response2007_data.py | 0 .../test/test_inline_response_default.py | 0 {pysky_api => skyapi}/tox.ini | 0 skycoin/restapi/__init__.py | 27 - skycoin/restapi/api/__init__.py | 6 - skycoin/restapi/api/default_api.py | 488 -------------- skycoin/restapi/api_client.py | 620 ------------------ skycoin/restapi/configuration.py | 246 ------- skycoin/restapi/models/__init__.py | 20 - skycoin/restapi/models/build_info.py | 169 ----- skycoin/restapi/models/inline_response_200.py | 113 ---- skycoin/restapi/models/inline_response_422.py | 163 ----- .../restapi/models/inline_response_default.py | 137 ---- skycoin/restapi/rest.py | 322 --------- 96 files changed, 15 insertions(+), 2331 deletions(-) rename {pysky_api => skyapi}/.gitignore (100%) rename {pysky_api => skyapi}/.openapi-generator-ignore (100%) rename {pysky_api => skyapi}/.openapi-generator/VERSION (100%) rename {pysky_api => skyapi}/.travis.yml (100%) rename {pysky_api => skyapi}/README.md (100%) rename {pysky_api => skyapi}/docs/Apiv1exploreraddressInputs.md (100%) rename {pysky_api => skyapi}/docs/Apiv1exploreraddressOutputs.md (100%) rename {pysky_api => skyapi}/docs/Apiv1exploreraddressStatus.md (100%) rename {pysky_api => skyapi}/docs/Apiv1pendingTxsTransaction.md (100%) rename {pysky_api => skyapi}/docs/Apiv1walletsEntries.md (100%) rename {pysky_api => skyapi}/docs/Apiv1walletsMeta.md (100%) rename {pysky_api => skyapi}/docs/Apiv1wallettransactionHoursSelection.md (100%) rename {pysky_api => skyapi}/docs/Apiv1wallettransactionTo.md (100%) rename {pysky_api => skyapi}/docs/Apiv1wallettransactionWallet.md (100%) rename {pysky_api => skyapi}/docs/DefaultApi.md (100%) rename {pysky_api => skyapi}/docs/InlineObject.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse200.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2001.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2002.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2003.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2003UnconfirmedVerifyTransaction.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2004.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2005.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2006.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2007.md (100%) rename {pysky_api => skyapi}/docs/InlineResponse2007Data.md (100%) rename {pysky_api => skyapi}/docs/InlineResponseDefault.md (100%) rename {pysky_api => skyapi}/git_push.sh (100%) rename {pysky_api => skyapi}/openapi_client/__init__.py (100%) rename {pysky_api => skyapi}/openapi_client/api/__init__.py (100%) rename {pysky_api => skyapi}/openapi_client/api/default_api.py (100%) rename {pysky_api => skyapi}/openapi_client/api_client.py (100%) rename {pysky_api => skyapi}/openapi_client/configuration.py (100%) rename {pysky_api => skyapi}/openapi_client/models/__init__.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1exploreraddress_inputs.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1exploreraddress_outputs.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1exploreraddress_status.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1pending_txs_transaction.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1wallets_entries.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1wallets_meta.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1wallettransaction_hours_selection.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1wallettransaction_to.py (100%) rename {pysky_api => skyapi}/openapi_client/models/apiv1wallettransaction_wallet.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_object.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response200.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2001.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2002.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2003.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2004.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2005.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2006.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2007.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response2007_data.py (100%) rename {pysky_api => skyapi}/openapi_client/models/inline_response_default.py (100%) rename {pysky_api => skyapi}/openapi_client/rest.py (100%) rename {pysky_api => skyapi}/requirements.txt (100%) rename {pysky_api => skyapi}/setup.py (100%) rename {pysky_api => skyapi}/test-requirements.txt (100%) rename {pysky_api => skyapi}/test/__init__.py (100%) rename {pysky_api => skyapi}/test/test_apiv1exploreraddress_inputs.py (100%) rename {pysky_api => skyapi}/test/test_apiv1exploreraddress_outputs.py (100%) rename {pysky_api => skyapi}/test/test_apiv1exploreraddress_status.py (100%) rename {pysky_api => skyapi}/test/test_apiv1pending_txs_transaction.py (100%) rename {pysky_api => skyapi}/test/test_apiv1wallets_entries.py (100%) rename {pysky_api => skyapi}/test/test_apiv1wallets_meta.py (100%) rename {pysky_api => skyapi}/test/test_apiv1wallettransaction_hours_selection.py (100%) rename {pysky_api => skyapi}/test/test_apiv1wallettransaction_to.py (100%) rename {pysky_api => skyapi}/test/test_apiv1wallettransaction_wallet.py (100%) rename {pysky_api => skyapi}/test/test_default_api.py (100%) rename {pysky_api => skyapi}/test/test_inline_object.py (100%) rename {pysky_api => skyapi}/test/test_inline_response200.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2001.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2002.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2003.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2003_unconfirmed_verify_transaction.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2004.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2005.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2006.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2007.py (100%) rename {pysky_api => skyapi}/test/test_inline_response2007_data.py (100%) rename {pysky_api => skyapi}/test/test_inline_response_default.py (100%) rename {pysky_api => skyapi}/tox.ini (100%) delete mode 100644 skycoin/restapi/__init__.py delete mode 100644 skycoin/restapi/api/__init__.py delete mode 100644 skycoin/restapi/api/default_api.py delete mode 100644 skycoin/restapi/api_client.py delete mode 100644 skycoin/restapi/configuration.py delete mode 100644 skycoin/restapi/models/__init__.py delete mode 100644 skycoin/restapi/models/build_info.py delete mode 100644 skycoin/restapi/models/inline_response_200.py delete mode 100644 skycoin/restapi/models/inline_response_422.py delete mode 100644 skycoin/restapi/models/inline_response_default.py delete mode 100644 skycoin/restapi/rest.py diff --git a/.travis/install-linux.sh b/.travis/install-linux.sh index dbbd0105..7ddf1a5d 100644 --- a/.travis/install-linux.sh +++ b/.travis/install-linux.sh @@ -18,8 +18,8 @@ chmod +x "$HOME/bin/gimme" # Install Python libraries $PIP install --upgrade pip setuptools tox-travis $PIP install -r "$REPO_ROOT/requirements.dev.txt" -$PIP install -r "$REPO_ROOT/pysky_api/requirements.txt" -$PIP install -r "$REPO_ROOT/pysky_api/test-requirements.txt" +$PIP install -r "$REPO_ROOT/skyapi/requirements.txt" +$PIP install -r "$REPO_ROOT/skyapi/test-requirements.txt" # Compile SWIG mkdir swig_build && \ diff --git a/Makefile b/Makefile index d477d260..e9b17f22 100644 --- a/Makefile +++ b/Makefile @@ -1,12 +1,12 @@ .DEFAULT_GOAL := help -.PHONY: configure build-libc build-swig develop build-libc-swig build build-pysky_api +.PHONY: configure build-libc build-swig develop build-libc-swig build .PHONY: test test-ci help # Compilation output .ONESHELL: SHELL := /bin/bash -PYTHON_BIN = python +PYTHON = python PWD = $(shell pwd) GOPATH_DIR = $(PWD)/gopath SKYCOIN_DIR = gopath/src/github.com/skycoin/skycoin @@ -25,7 +25,7 @@ SRC_FILES = $(shell find $(SKYCOIN_DIR)/src -type f -name "*.go") SWIG_FILES = $(shell find $(LIBSWIG_DIR) -type f -name "*.i") HEADER_FILES = $(shell find $(SKYCOIN_DIR)/include -type f -name "*.h") -PYTHON_CLIENT_DIR = pysky_api +PYTHON_CLIENT_DIR = skyapi ifeq ($(shell uname -s),Linux) TEMP_DIR = tmp @@ -38,11 +38,6 @@ configure: ## Configure build environment mkdir -p $(BUILDLIBC_DIR) $(BIN_DIR) $(INCLUDE_DIR) mkdir -p $(DIST_DIR) -generate-python-Client: ## Configure build environment - mkdir -p $(BUILD_DIR)/usr/tmp $(BUILD_DIR)/usr/lib $(BUILD_DIR)/usr/include - mkdir -p $(BUILDLIBC_DIR) $(BIN_DIR) $(INCLUDE_DIR) - mkdir -p $(DIST_DIR) - $(BUILDLIBC_DIR)/libskycoin.a: $(LIB_FILES) $(SRC_FILES) $(HEADER_FILES) rm -f $(BUILDLIBC_DIR)/libskycoin.a GOPATH="$(GOPATH_DIR)" make -C $(SKYCOIN_DIR) build-libc-static @@ -72,30 +67,30 @@ build-swig: ## Generate Python C module from SWIG interfaces swig -python -Iswig/include -I$(INCLUDE_DIR) -outdir ./skycoin/ -o swig/pyskycoin_wrap.c $(LIBSWIG_DIR)/pyskycoin.i develop: ## Install PySkycoin for development - $(PYTHON_BIN) setup.py develop - (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py develop) + $(PYTHON) setup.py develop + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON) setup.py develop) build-libc-swig: build-libc build-swig build: build-libc-swig ## Build PySkycoin Python package - $(PYTHON_BIN) setup.py build - (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py build) + $(PYTHON) setup.py build + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON) setup.py build) test-ci: ## Run tests on (Travis) CI build tox (cd $(PYTHON_CLIENT_DIR) && tox) test: build-libc build-swig develop ## Run project test suite - $(PYTHON_BIN) setup.py test - (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py test) + $(PYTHON) setup.py test + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON) setup.py test) sdist: ## Create source distribution archive - $(PYTHON_BIN) setup.py sdist --formats=gztar - (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py sdist --formats=gztar) + $(PYTHON) setup.py sdist --formats=gztar + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON) setup.py sdist --formats=gztar) bdist_wheel: ## Create architecture-specific binary wheel distribution archive - $(PYTHON_BIN) setup.py bdist_wheel - (cd $(PYTHON_CLIENT_DIR) && $(PYTHON_BIN) setup.py bdist_wheel) + $(PYTHON) setup.py bdist_wheel + (cd $(PYTHON_CLIENT_DIR) && $(PYTHON) setup.py bdist_wheel) # FIXME: After libskycoin 32-bits binaries add bdist_manylinux_i686 bdist_manylinux: bdist_manylinux_amd64 ## Create multilinux binary wheel distribution archives diff --git a/pysky_api/.gitignore b/skyapi/.gitignore similarity index 100% rename from pysky_api/.gitignore rename to skyapi/.gitignore diff --git a/pysky_api/.openapi-generator-ignore b/skyapi/.openapi-generator-ignore similarity index 100% rename from pysky_api/.openapi-generator-ignore rename to skyapi/.openapi-generator-ignore diff --git a/pysky_api/.openapi-generator/VERSION b/skyapi/.openapi-generator/VERSION similarity index 100% rename from pysky_api/.openapi-generator/VERSION rename to skyapi/.openapi-generator/VERSION diff --git a/pysky_api/.travis.yml b/skyapi/.travis.yml similarity index 100% rename from pysky_api/.travis.yml rename to skyapi/.travis.yml diff --git a/pysky_api/README.md b/skyapi/README.md similarity index 100% rename from pysky_api/README.md rename to skyapi/README.md diff --git a/pysky_api/docs/Apiv1exploreraddressInputs.md b/skyapi/docs/Apiv1exploreraddressInputs.md similarity index 100% rename from pysky_api/docs/Apiv1exploreraddressInputs.md rename to skyapi/docs/Apiv1exploreraddressInputs.md diff --git a/pysky_api/docs/Apiv1exploreraddressOutputs.md b/skyapi/docs/Apiv1exploreraddressOutputs.md similarity index 100% rename from pysky_api/docs/Apiv1exploreraddressOutputs.md rename to skyapi/docs/Apiv1exploreraddressOutputs.md diff --git a/pysky_api/docs/Apiv1exploreraddressStatus.md b/skyapi/docs/Apiv1exploreraddressStatus.md similarity index 100% rename from pysky_api/docs/Apiv1exploreraddressStatus.md rename to skyapi/docs/Apiv1exploreraddressStatus.md diff --git a/pysky_api/docs/Apiv1pendingTxsTransaction.md b/skyapi/docs/Apiv1pendingTxsTransaction.md similarity index 100% rename from pysky_api/docs/Apiv1pendingTxsTransaction.md rename to skyapi/docs/Apiv1pendingTxsTransaction.md diff --git a/pysky_api/docs/Apiv1walletsEntries.md b/skyapi/docs/Apiv1walletsEntries.md similarity index 100% rename from pysky_api/docs/Apiv1walletsEntries.md rename to skyapi/docs/Apiv1walletsEntries.md diff --git a/pysky_api/docs/Apiv1walletsMeta.md b/skyapi/docs/Apiv1walletsMeta.md similarity index 100% rename from pysky_api/docs/Apiv1walletsMeta.md rename to skyapi/docs/Apiv1walletsMeta.md diff --git a/pysky_api/docs/Apiv1wallettransactionHoursSelection.md b/skyapi/docs/Apiv1wallettransactionHoursSelection.md similarity index 100% rename from pysky_api/docs/Apiv1wallettransactionHoursSelection.md rename to skyapi/docs/Apiv1wallettransactionHoursSelection.md diff --git a/pysky_api/docs/Apiv1wallettransactionTo.md b/skyapi/docs/Apiv1wallettransactionTo.md similarity index 100% rename from pysky_api/docs/Apiv1wallettransactionTo.md rename to skyapi/docs/Apiv1wallettransactionTo.md diff --git a/pysky_api/docs/Apiv1wallettransactionWallet.md b/skyapi/docs/Apiv1wallettransactionWallet.md similarity index 100% rename from pysky_api/docs/Apiv1wallettransactionWallet.md rename to skyapi/docs/Apiv1wallettransactionWallet.md diff --git a/pysky_api/docs/DefaultApi.md b/skyapi/docs/DefaultApi.md similarity index 100% rename from pysky_api/docs/DefaultApi.md rename to skyapi/docs/DefaultApi.md diff --git a/pysky_api/docs/InlineObject.md b/skyapi/docs/InlineObject.md similarity index 100% rename from pysky_api/docs/InlineObject.md rename to skyapi/docs/InlineObject.md diff --git a/pysky_api/docs/InlineResponse200.md b/skyapi/docs/InlineResponse200.md similarity index 100% rename from pysky_api/docs/InlineResponse200.md rename to skyapi/docs/InlineResponse200.md diff --git a/pysky_api/docs/InlineResponse2001.md b/skyapi/docs/InlineResponse2001.md similarity index 100% rename from pysky_api/docs/InlineResponse2001.md rename to skyapi/docs/InlineResponse2001.md diff --git a/pysky_api/docs/InlineResponse2002.md b/skyapi/docs/InlineResponse2002.md similarity index 100% rename from pysky_api/docs/InlineResponse2002.md rename to skyapi/docs/InlineResponse2002.md diff --git a/pysky_api/docs/InlineResponse2003.md b/skyapi/docs/InlineResponse2003.md similarity index 100% rename from pysky_api/docs/InlineResponse2003.md rename to skyapi/docs/InlineResponse2003.md diff --git a/pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md b/skyapi/docs/InlineResponse2003UnconfirmedVerifyTransaction.md similarity index 100% rename from pysky_api/docs/InlineResponse2003UnconfirmedVerifyTransaction.md rename to skyapi/docs/InlineResponse2003UnconfirmedVerifyTransaction.md diff --git a/pysky_api/docs/InlineResponse2004.md b/skyapi/docs/InlineResponse2004.md similarity index 100% rename from pysky_api/docs/InlineResponse2004.md rename to skyapi/docs/InlineResponse2004.md diff --git a/pysky_api/docs/InlineResponse2005.md b/skyapi/docs/InlineResponse2005.md similarity index 100% rename from pysky_api/docs/InlineResponse2005.md rename to skyapi/docs/InlineResponse2005.md diff --git a/pysky_api/docs/InlineResponse2006.md b/skyapi/docs/InlineResponse2006.md similarity index 100% rename from pysky_api/docs/InlineResponse2006.md rename to skyapi/docs/InlineResponse2006.md diff --git a/pysky_api/docs/InlineResponse2007.md b/skyapi/docs/InlineResponse2007.md similarity index 100% rename from pysky_api/docs/InlineResponse2007.md rename to skyapi/docs/InlineResponse2007.md diff --git a/pysky_api/docs/InlineResponse2007Data.md b/skyapi/docs/InlineResponse2007Data.md similarity index 100% rename from pysky_api/docs/InlineResponse2007Data.md rename to skyapi/docs/InlineResponse2007Data.md diff --git a/pysky_api/docs/InlineResponseDefault.md b/skyapi/docs/InlineResponseDefault.md similarity index 100% rename from pysky_api/docs/InlineResponseDefault.md rename to skyapi/docs/InlineResponseDefault.md diff --git a/pysky_api/git_push.sh b/skyapi/git_push.sh similarity index 100% rename from pysky_api/git_push.sh rename to skyapi/git_push.sh diff --git a/pysky_api/openapi_client/__init__.py b/skyapi/openapi_client/__init__.py similarity index 100% rename from pysky_api/openapi_client/__init__.py rename to skyapi/openapi_client/__init__.py diff --git a/pysky_api/openapi_client/api/__init__.py b/skyapi/openapi_client/api/__init__.py similarity index 100% rename from pysky_api/openapi_client/api/__init__.py rename to skyapi/openapi_client/api/__init__.py diff --git a/pysky_api/openapi_client/api/default_api.py b/skyapi/openapi_client/api/default_api.py similarity index 100% rename from pysky_api/openapi_client/api/default_api.py rename to skyapi/openapi_client/api/default_api.py diff --git a/pysky_api/openapi_client/api_client.py b/skyapi/openapi_client/api_client.py similarity index 100% rename from pysky_api/openapi_client/api_client.py rename to skyapi/openapi_client/api_client.py diff --git a/pysky_api/openapi_client/configuration.py b/skyapi/openapi_client/configuration.py similarity index 100% rename from pysky_api/openapi_client/configuration.py rename to skyapi/openapi_client/configuration.py diff --git a/pysky_api/openapi_client/models/__init__.py b/skyapi/openapi_client/models/__init__.py similarity index 100% rename from pysky_api/openapi_client/models/__init__.py rename to skyapi/openapi_client/models/__init__.py diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py b/skyapi/openapi_client/models/apiv1exploreraddress_inputs.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1exploreraddress_inputs.py rename to skyapi/openapi_client/models/apiv1exploreraddress_inputs.py diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py b/skyapi/openapi_client/models/apiv1exploreraddress_outputs.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1exploreraddress_outputs.py rename to skyapi/openapi_client/models/apiv1exploreraddress_outputs.py diff --git a/pysky_api/openapi_client/models/apiv1exploreraddress_status.py b/skyapi/openapi_client/models/apiv1exploreraddress_status.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1exploreraddress_status.py rename to skyapi/openapi_client/models/apiv1exploreraddress_status.py diff --git a/pysky_api/openapi_client/models/apiv1pending_txs_transaction.py b/skyapi/openapi_client/models/apiv1pending_txs_transaction.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1pending_txs_transaction.py rename to skyapi/openapi_client/models/apiv1pending_txs_transaction.py diff --git a/pysky_api/openapi_client/models/apiv1wallets_entries.py b/skyapi/openapi_client/models/apiv1wallets_entries.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1wallets_entries.py rename to skyapi/openapi_client/models/apiv1wallets_entries.py diff --git a/pysky_api/openapi_client/models/apiv1wallets_meta.py b/skyapi/openapi_client/models/apiv1wallets_meta.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1wallets_meta.py rename to skyapi/openapi_client/models/apiv1wallets_meta.py diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py b/skyapi/openapi_client/models/apiv1wallettransaction_hours_selection.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1wallettransaction_hours_selection.py rename to skyapi/openapi_client/models/apiv1wallettransaction_hours_selection.py diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_to.py b/skyapi/openapi_client/models/apiv1wallettransaction_to.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1wallettransaction_to.py rename to skyapi/openapi_client/models/apiv1wallettransaction_to.py diff --git a/pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py b/skyapi/openapi_client/models/apiv1wallettransaction_wallet.py similarity index 100% rename from pysky_api/openapi_client/models/apiv1wallettransaction_wallet.py rename to skyapi/openapi_client/models/apiv1wallettransaction_wallet.py diff --git a/pysky_api/openapi_client/models/inline_object.py b/skyapi/openapi_client/models/inline_object.py similarity index 100% rename from pysky_api/openapi_client/models/inline_object.py rename to skyapi/openapi_client/models/inline_object.py diff --git a/pysky_api/openapi_client/models/inline_response200.py b/skyapi/openapi_client/models/inline_response200.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response200.py rename to skyapi/openapi_client/models/inline_response200.py diff --git a/pysky_api/openapi_client/models/inline_response2001.py b/skyapi/openapi_client/models/inline_response2001.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2001.py rename to skyapi/openapi_client/models/inline_response2001.py diff --git a/pysky_api/openapi_client/models/inline_response2002.py b/skyapi/openapi_client/models/inline_response2002.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2002.py rename to skyapi/openapi_client/models/inline_response2002.py diff --git a/pysky_api/openapi_client/models/inline_response2003.py b/skyapi/openapi_client/models/inline_response2003.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2003.py rename to skyapi/openapi_client/models/inline_response2003.py diff --git a/pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py b/skyapi/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py rename to skyapi/openapi_client/models/inline_response2003_unconfirmed_verify_transaction.py diff --git a/pysky_api/openapi_client/models/inline_response2004.py b/skyapi/openapi_client/models/inline_response2004.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2004.py rename to skyapi/openapi_client/models/inline_response2004.py diff --git a/pysky_api/openapi_client/models/inline_response2005.py b/skyapi/openapi_client/models/inline_response2005.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2005.py rename to skyapi/openapi_client/models/inline_response2005.py diff --git a/pysky_api/openapi_client/models/inline_response2006.py b/skyapi/openapi_client/models/inline_response2006.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2006.py rename to skyapi/openapi_client/models/inline_response2006.py diff --git a/pysky_api/openapi_client/models/inline_response2007.py b/skyapi/openapi_client/models/inline_response2007.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2007.py rename to skyapi/openapi_client/models/inline_response2007.py diff --git a/pysky_api/openapi_client/models/inline_response2007_data.py b/skyapi/openapi_client/models/inline_response2007_data.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response2007_data.py rename to skyapi/openapi_client/models/inline_response2007_data.py diff --git a/pysky_api/openapi_client/models/inline_response_default.py b/skyapi/openapi_client/models/inline_response_default.py similarity index 100% rename from pysky_api/openapi_client/models/inline_response_default.py rename to skyapi/openapi_client/models/inline_response_default.py diff --git a/pysky_api/openapi_client/rest.py b/skyapi/openapi_client/rest.py similarity index 100% rename from pysky_api/openapi_client/rest.py rename to skyapi/openapi_client/rest.py diff --git a/pysky_api/requirements.txt b/skyapi/requirements.txt similarity index 100% rename from pysky_api/requirements.txt rename to skyapi/requirements.txt diff --git a/pysky_api/setup.py b/skyapi/setup.py similarity index 100% rename from pysky_api/setup.py rename to skyapi/setup.py diff --git a/pysky_api/test-requirements.txt b/skyapi/test-requirements.txt similarity index 100% rename from pysky_api/test-requirements.txt rename to skyapi/test-requirements.txt diff --git a/pysky_api/test/__init__.py b/skyapi/test/__init__.py similarity index 100% rename from pysky_api/test/__init__.py rename to skyapi/test/__init__.py diff --git a/pysky_api/test/test_apiv1exploreraddress_inputs.py b/skyapi/test/test_apiv1exploreraddress_inputs.py similarity index 100% rename from pysky_api/test/test_apiv1exploreraddress_inputs.py rename to skyapi/test/test_apiv1exploreraddress_inputs.py diff --git a/pysky_api/test/test_apiv1exploreraddress_outputs.py b/skyapi/test/test_apiv1exploreraddress_outputs.py similarity index 100% rename from pysky_api/test/test_apiv1exploreraddress_outputs.py rename to skyapi/test/test_apiv1exploreraddress_outputs.py diff --git a/pysky_api/test/test_apiv1exploreraddress_status.py b/skyapi/test/test_apiv1exploreraddress_status.py similarity index 100% rename from pysky_api/test/test_apiv1exploreraddress_status.py rename to skyapi/test/test_apiv1exploreraddress_status.py diff --git a/pysky_api/test/test_apiv1pending_txs_transaction.py b/skyapi/test/test_apiv1pending_txs_transaction.py similarity index 100% rename from pysky_api/test/test_apiv1pending_txs_transaction.py rename to skyapi/test/test_apiv1pending_txs_transaction.py diff --git a/pysky_api/test/test_apiv1wallets_entries.py b/skyapi/test/test_apiv1wallets_entries.py similarity index 100% rename from pysky_api/test/test_apiv1wallets_entries.py rename to skyapi/test/test_apiv1wallets_entries.py diff --git a/pysky_api/test/test_apiv1wallets_meta.py b/skyapi/test/test_apiv1wallets_meta.py similarity index 100% rename from pysky_api/test/test_apiv1wallets_meta.py rename to skyapi/test/test_apiv1wallets_meta.py diff --git a/pysky_api/test/test_apiv1wallettransaction_hours_selection.py b/skyapi/test/test_apiv1wallettransaction_hours_selection.py similarity index 100% rename from pysky_api/test/test_apiv1wallettransaction_hours_selection.py rename to skyapi/test/test_apiv1wallettransaction_hours_selection.py diff --git a/pysky_api/test/test_apiv1wallettransaction_to.py b/skyapi/test/test_apiv1wallettransaction_to.py similarity index 100% rename from pysky_api/test/test_apiv1wallettransaction_to.py rename to skyapi/test/test_apiv1wallettransaction_to.py diff --git a/pysky_api/test/test_apiv1wallettransaction_wallet.py b/skyapi/test/test_apiv1wallettransaction_wallet.py similarity index 100% rename from pysky_api/test/test_apiv1wallettransaction_wallet.py rename to skyapi/test/test_apiv1wallettransaction_wallet.py diff --git a/pysky_api/test/test_default_api.py b/skyapi/test/test_default_api.py similarity index 100% rename from pysky_api/test/test_default_api.py rename to skyapi/test/test_default_api.py diff --git a/pysky_api/test/test_inline_object.py b/skyapi/test/test_inline_object.py similarity index 100% rename from pysky_api/test/test_inline_object.py rename to skyapi/test/test_inline_object.py diff --git a/pysky_api/test/test_inline_response200.py b/skyapi/test/test_inline_response200.py similarity index 100% rename from pysky_api/test/test_inline_response200.py rename to skyapi/test/test_inline_response200.py diff --git a/pysky_api/test/test_inline_response2001.py b/skyapi/test/test_inline_response2001.py similarity index 100% rename from pysky_api/test/test_inline_response2001.py rename to skyapi/test/test_inline_response2001.py diff --git a/pysky_api/test/test_inline_response2002.py b/skyapi/test/test_inline_response2002.py similarity index 100% rename from pysky_api/test/test_inline_response2002.py rename to skyapi/test/test_inline_response2002.py diff --git a/pysky_api/test/test_inline_response2003.py b/skyapi/test/test_inline_response2003.py similarity index 100% rename from pysky_api/test/test_inline_response2003.py rename to skyapi/test/test_inline_response2003.py diff --git a/pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py b/skyapi/test/test_inline_response2003_unconfirmed_verify_transaction.py similarity index 100% rename from pysky_api/test/test_inline_response2003_unconfirmed_verify_transaction.py rename to skyapi/test/test_inline_response2003_unconfirmed_verify_transaction.py diff --git a/pysky_api/test/test_inline_response2004.py b/skyapi/test/test_inline_response2004.py similarity index 100% rename from pysky_api/test/test_inline_response2004.py rename to skyapi/test/test_inline_response2004.py diff --git a/pysky_api/test/test_inline_response2005.py b/skyapi/test/test_inline_response2005.py similarity index 100% rename from pysky_api/test/test_inline_response2005.py rename to skyapi/test/test_inline_response2005.py diff --git a/pysky_api/test/test_inline_response2006.py b/skyapi/test/test_inline_response2006.py similarity index 100% rename from pysky_api/test/test_inline_response2006.py rename to skyapi/test/test_inline_response2006.py diff --git a/pysky_api/test/test_inline_response2007.py b/skyapi/test/test_inline_response2007.py similarity index 100% rename from pysky_api/test/test_inline_response2007.py rename to skyapi/test/test_inline_response2007.py diff --git a/pysky_api/test/test_inline_response2007_data.py b/skyapi/test/test_inline_response2007_data.py similarity index 100% rename from pysky_api/test/test_inline_response2007_data.py rename to skyapi/test/test_inline_response2007_data.py diff --git a/pysky_api/test/test_inline_response_default.py b/skyapi/test/test_inline_response_default.py similarity index 100% rename from pysky_api/test/test_inline_response_default.py rename to skyapi/test/test_inline_response_default.py diff --git a/pysky_api/tox.ini b/skyapi/tox.ini similarity index 100% rename from pysky_api/tox.ini rename to skyapi/tox.ini diff --git a/skycoin/restapi/__init__.py b/skycoin/restapi/__init__.py deleted file mode 100644 index 3f02b925..00000000 --- a/skycoin/restapi/__init__.py +++ /dev/null @@ -1,27 +0,0 @@ -# coding: utf-8 - -# flake8: noqa - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -# import apis into sdk package -from swagger_client.api.default_api import DefaultApi - -# import ApiClient -from swagger_client.api_client import ApiClient -from swagger_client.configuration import Configuration -# import models into sdk package -from swagger_client.models.build_info import BuildInfo -from swagger_client.models.inline_response_200 import InlineResponse200 -from swagger_client.models.inline_response_422 import InlineResponse422 -from swagger_client.models.inline_response_default import InlineResponseDefault diff --git a/skycoin/restapi/api/__init__.py b/skycoin/restapi/api/__init__.py deleted file mode 100644 index 447bb1c3..00000000 --- a/skycoin/restapi/api/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -from __future__ import absolute_import - -# flake8: noqa - -# import apis into api package -from swagger_client.api.default_api import DefaultApi diff --git a/skycoin/restapi/api/default_api.py b/skycoin/restapi/api/default_api.py deleted file mode 100644 index 98cea980..00000000 --- a/skycoin/restapi/api/default_api.py +++ /dev/null @@ -1,488 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import re # noqa: F401 - -# python 2 and python 3 compatibility library -import six - -from swagger_client.api_client import ApiClient - - -class DefaultApi(object): - """NOTE: This class is auto generated by the swagger code generator program. - - Do not edit the class manually. - Ref: https://github.com/swagger-api/swagger-codegen - """ - - def __init__(self, api_client=None): - if api_client is None: - api_client = ApiClient() - self.api_client = api_client - - def coin_supply(self, **kwargs): # noqa: E501 - """coin_supply # noqa: E501 - - coinSupplyHandler returns coin distribution supply stats # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.coin_supply(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - kwargs['_return_http_data_only'] = True - if kwargs.get('async'): - return self.coin_supply_with_http_info(**kwargs) # noqa: E501 - else: - (data) = self.coin_supply_with_http_info(**kwargs) # noqa: E501 - return data - - def coin_supply_with_http_info(self, **kwargs): # noqa: E501 - """coin_supply # noqa: E501 - - coinSupplyHandler returns coin distribution supply stats # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.coin_supply_with_http_info(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - - all_params = [] # noqa: E501 - all_params.append('async') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - - params = locals() - for key, val in six.iteritems(params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method coin_supply" % key - ) - params[key] = val - del params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = ['csrfAuth'] # noqa: E501 - - return self.api_client.call_api( - '/api/v1/coinSupply', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async=params.get('async'), - _return_http_data_only=params.get('_return_http_data_only'), - _preload_content=params.get('_preload_content', True), - _request_timeout=params.get('_request_timeout'), - collection_formats=collection_formats) - - def csrf_token(self, **kwargs): # noqa: E501 - """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 - - Response -> CSRF token to use in POST requests # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.csrf_token(async=True) - >>> result = thread.get() - - :param async bool - :return: InlineResponse200 - If the method is called asynchronously, - returns the request thread. - """ - kwargs['_return_http_data_only'] = True - if kwargs.get('async'): - return self.csrf_token_with_http_info(**kwargs) # noqa: E501 - else: - (data) = self.csrf_token_with_http_info(**kwargs) # noqa: E501 - return data - - def csrf_token_with_http_info(self, **kwargs): # noqa: E501 - """Creates a new CSRF token. Previous CSRF tokens are invalidated by this call. # noqa: E501 - - Response -> CSRF token to use in POST requests # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.csrf_token_with_http_info(async=True) - >>> result = thread.get() - - :param async bool - :return: InlineResponse200 - If the method is called asynchronously, - returns the request thread. - """ - - all_params = [] # noqa: E501 - all_params.append('async') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - - params = locals() - for key, val in six.iteritems(params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method csrf_token" % key - ) - params[key] = val - del params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = ['csrfAuth'] # noqa: E501 - - return self.api_client.call_api( - '/api/v1/csrf', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='InlineResponse200', # noqa: E501 - auth_settings=auth_settings, - async=params.get('async'), - _return_http_data_only=params.get('_return_http_data_only'), - _preload_content=params.get('_preload_content', True), - _request_timeout=params.get('_request_timeout'), - collection_formats=collection_formats) - - def resend_unconfirmed_txns(self, **kwargs): # noqa: E501 - """resend_unconfirmed_txns # noqa: E501 - - Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.resend_unconfirmed_txns(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - kwargs['_return_http_data_only'] = True - if kwargs.get('async'): - return self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 - else: - (data) = self.resend_unconfirmed_txns_with_http_info(**kwargs) # noqa: E501 - return data - - def resend_unconfirmed_txns_with_http_info(self, **kwargs): # noqa: E501 - """resend_unconfirmed_txns # noqa: E501 - - Broadcasts all unconfirmed transactions from the unconfirmed transaction pool # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.resend_unconfirmed_txns_with_http_info(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - - all_params = [] # noqa: E501 - all_params.append('async') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - - params = locals() - for key, val in six.iteritems(params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method resend_unconfirmed_txns" % key - ) - params[key] = val - del params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = ['csrfAuth'] # noqa: E501 - - return self.api_client.call_api( - '/api/v1/resendUnconfirmedTxns', 'POST', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async=params.get('async'), - _return_http_data_only=params.get('_return_http_data_only'), - _preload_content=params.get('_preload_content', True), - _request_timeout=params.get('_request_timeout'), - collection_formats=collection_formats) - - def version(self, **kwargs): # noqa: E501 - """version # noqa: E501 - - versionHandler returns the application version info # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.version(async=True) - >>> result = thread.get() - - :param async bool - :return: BuildInfo - If the method is called asynchronously, - returns the request thread. - """ - kwargs['_return_http_data_only'] = True - if kwargs.get('async'): - return self.version_with_http_info(**kwargs) # noqa: E501 - else: - (data) = self.version_with_http_info(**kwargs) # noqa: E501 - return data - - def version_with_http_info(self, **kwargs): # noqa: E501 - """version # noqa: E501 - - versionHandler returns the application version info # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.version_with_http_info(async=True) - >>> result = thread.get() - - :param async bool - :return: BuildInfo - If the method is called asynchronously, - returns the request thread. - """ - - all_params = [] # noqa: E501 - all_params.append('async') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - - params = locals() - for key, val in six.iteritems(params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method version" % key - ) - params[key] = val - del params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = ['csrfAuth'] # noqa: E501 - - return self.api_client.call_api( - '/api/v1/version', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type='BuildInfo', # noqa: E501 - auth_settings=auth_settings, - async=params.get('async'), - _return_http_data_only=params.get('_return_http_data_only'), - _preload_content=params.get('_preload_content', True), - _request_timeout=params.get('_request_timeout'), - collection_formats=collection_formats) - - def wallet_folder(self, **kwargs): # noqa: E501 - """wallet_folder # noqa: E501 - - Returns the wallet directory path # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.wallet_folder(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - kwargs['_return_http_data_only'] = True - if kwargs.get('async'): - return self.wallet_folder_with_http_info(**kwargs) # noqa: E501 - else: - (data) = self.wallet_folder_with_http_info(**kwargs) # noqa: E501 - return data - - def wallet_folder_with_http_info(self, **kwargs): # noqa: E501 - """wallet_folder # noqa: E501 - - Returns the wallet directory path # noqa: E501 - This method makes a synchronous HTTP request by default. To make an - asynchronous HTTP request, please pass async=True - >>> thread = api.wallet_folder_with_http_info(async=True) - >>> result = thread.get() - - :param async bool - :return: None - If the method is called asynchronously, - returns the request thread. - """ - - all_params = [] # noqa: E501 - all_params.append('async') - all_params.append('_return_http_data_only') - all_params.append('_preload_content') - all_params.append('_request_timeout') - - params = locals() - for key, val in six.iteritems(params['kwargs']): - if key not in all_params: - raise TypeError( - "Got an unexpected keyword argument '%s'" - " to method wallet_folder" % key - ) - params[key] = val - del params['kwargs'] - - collection_formats = {} - - path_params = {} - - query_params = [] - - header_params = {} - - form_params = [] - local_var_files = {} - - body_params = None - # HTTP header `Accept` - header_params['Accept'] = self.api_client.select_header_accept( - ['application/json']) # noqa: E501 - - # HTTP header `Content-Type` - header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 - ['application/json']) # noqa: E501 - - # Authentication setting - auth_settings = ['csrfAuth'] # noqa: E501 - - return self.api_client.call_api( - '/api/v1/wallets/folderName', 'GET', - path_params, - query_params, - header_params, - body=body_params, - post_params=form_params, - files=local_var_files, - response_type=None, # noqa: E501 - auth_settings=auth_settings, - async=params.get('async'), - _return_http_data_only=params.get('_return_http_data_only'), - _preload_content=params.get('_preload_content', True), - _request_timeout=params.get('_request_timeout'), - collection_formats=collection_formats) diff --git a/skycoin/restapi/api_client.py b/skycoin/restapi/api_client.py deleted file mode 100644 index fcaec015..00000000 --- a/skycoin/restapi/api_client.py +++ /dev/null @@ -1,620 +0,0 @@ -# coding: utf-8 -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - -from __future__ import absolute_import - -import datetime -import json -import mimetypes -from multiprocessing.pool import ThreadPool -import os -import re -import tempfile - -# python 2 and python 3 compatibility library -import six -from six.moves.urllib.parse import quote - -from swagger_client.configuration import Configuration -import swagger_client.models -from swagger_client import rest - - -class ApiClient(object): - """Generic API client for Swagger client library builds. - - Swagger generic API client. This client handles the client- - server communication, and is invariant across implementations. Specifics of - the methods and models for each application are generated from the Swagger - templates. - - NOTE: This class is auto generated by the swagger code generator program. - Ref: https://github.com/swagger-api/swagger-codegen - Do not edit the class manually. - - :param configuration: .Configuration object for this client - :param header_name: a header to pass when making calls to the API. - :param header_value: a header value to pass when making calls to - the API. - :param cookie: a cookie to include in the header when making calls - to the API - """ - - PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types - NATIVE_TYPES_MAPPING = { - 'int': int, - 'long': int if six.PY3 else long, # noqa: F821 - 'float': float, - 'str': str, - 'bool': bool, - 'date': datetime.date, - 'datetime': datetime.datetime, - 'object': object, - } - - def __init__(self, configuration=None, header_name=None, header_value=None, - cookie=None): - if configuration is None: - configuration = Configuration() - self.configuration = configuration - - self.pool = ThreadPool() - self.rest_client = rest.RESTClientObject(configuration) - self.default_headers = {} - if header_name is not None: - self.default_headers[header_name] = header_value - self.cookie = cookie - # Set default User-Agent. - self.user_agent = 'Swagger-Codegen/1.0.0/python' - - def __del__(self): - self.pool.close() - self.pool.join() - - @property - def user_agent(self): - """User agent for this API client""" - return self.default_headers['User-Agent'] - - @user_agent.setter - def user_agent(self, value): - self.default_headers['User-Agent'] = value - - def set_default_header(self, header_name, header_value): - self.default_headers[header_name] = header_value - - def __call_api( - self, resource_path, method, path_params=None, - query_params=None, header_params=None, body=None, post_params=None, - files=None, response_type=None, auth_settings=None, - _return_http_data_only=None, collection_formats=None, - _preload_content=True, _request_timeout=None): - - config = self.configuration - - # header parameters - header_params = header_params or {} - header_params.update(self.default_headers) - if self.cookie: - header_params['Cookie'] = self.cookie - if header_params: - header_params = self.sanitize_for_serialization(header_params) - header_params = dict(self.parameters_to_tuples(header_params, - collection_formats)) - - # path parameters - if path_params: - path_params = self.sanitize_for_serialization(path_params) - path_params = self.parameters_to_tuples(path_params, - collection_formats) - for k, v in path_params: - # specified safe chars, encode everything - resource_path = resource_path.replace( - '{%s}' % k, - quote(str(v), safe=config.safe_chars_for_path_param) - ) - - # query parameters - if query_params: - query_params = self.sanitize_for_serialization(query_params) - query_params = self.parameters_to_tuples(query_params, - collection_formats) - - # post parameters - if post_params or files: - post_params = self.prepare_post_parameters(post_params, files) - post_params = self.sanitize_for_serialization(post_params) - post_params = self.parameters_to_tuples(post_params, - collection_formats) - - # auth setting - self.update_params_for_auth(header_params, query_params, auth_settings) - - # body - if body: - body = self.sanitize_for_serialization(body) - - # request url - url = self.configuration.host + resource_path - - # perform request and return response - response_data = self.request( - method, url, query_params=query_params, headers=header_params, - post_params=post_params, body=body, - _preload_content=_preload_content, - _request_timeout=_request_timeout) - - self.last_response = response_data - - return_data = response_data - if _preload_content: - # deserialize response data - if response_type: - return_data = self.deserialize(response_data, response_type) - else: - return_data = None - - if _return_http_data_only: - return (return_data) - else: - return (return_data, response_data.status, - response_data.getheaders()) - - def sanitize_for_serialization(self, obj): - """Builds a JSON POST object. - - If obj is None, return None. - If obj is str, int, long, float, bool, return directly. - If obj is datetime.datetime, datetime.date - convert to string in iso8601 format. - If obj is list, sanitize each element in the list. - If obj is dict, return the dict. - If obj is swagger model, return the properties dict. - - :param obj: The data to serialize. - :return: The serialized form of data. - """ - if obj is None: - return None - elif isinstance(obj, self.PRIMITIVE_TYPES): - return obj - elif isinstance(obj, list): - return [self.sanitize_for_serialization(sub_obj) - for sub_obj in obj] - elif isinstance(obj, tuple): - return tuple(self.sanitize_for_serialization(sub_obj) - for sub_obj in obj) - elif isinstance(obj, (datetime.datetime, datetime.date)): - return obj.isoformat() - - if isinstance(obj, dict): - obj_dict = obj - else: - # Convert model obj to dict except - # attributes `swagger_types`, `attribute_map` - # and attributes which value is not None. - # Convert attribute name to json key in - # model definition for request. - obj_dict = {obj.attribute_map[attr]: getattr(obj, attr) - for attr, _ in six.iteritems(obj.swagger_types) - if getattr(obj, attr) is not None} - - return {key: self.sanitize_for_serialization(val) - for key, val in six.iteritems(obj_dict)} - - def deserialize(self, response, response_type): - """Deserializes response into an object. - - :param response: RESTResponse object to be deserialized. - :param response_type: class literal for - deserialized object, or string of class name. - - :return: deserialized object. - """ - # handle file downloading - # save response body into a tmp file and return the instance - if response_type == "file": - return self.__deserialize_file(response) - - # fetch data from response object - try: - data = json.loads(response.data) - except ValueError: - data = response.data - - return self.__deserialize(data, response_type) - - def __deserialize(self, data, klass): - """Deserializes dict, list, str into an object. - - :param data: dict, list or str. - :param klass: class literal, or string of class name. - - :return: object. - """ - if data is None: - return None - - if type(klass) == str: - if klass.startswith('list['): - sub_kls = re.match('list\[(.*)\]', klass).group(1) - return [self.__deserialize(sub_data, sub_kls) - for sub_data in data] - - if klass.startswith('dict('): - sub_kls = re.match('dict\(([^,]*), (.*)\)', klass).group(2) - return {k: self.__deserialize(v, sub_kls) - for k, v in six.iteritems(data)} - - # convert str to class - if klass in self.NATIVE_TYPES_MAPPING: - klass = self.NATIVE_TYPES_MAPPING[klass] - else: - klass = getattr(swagger_client.models, klass) - - if klass in self.PRIMITIVE_TYPES: - return self.__deserialize_primitive(data, klass) - elif klass == object: - return self.__deserialize_object(data) - elif klass == datetime.date: - return self.__deserialize_date(data) - elif klass == datetime.datetime: - return self.__deserialize_datatime(data) - else: - return self.__deserialize_model(data, klass) - - def call_api(self, resource_path, method, - path_params=None, query_params=None, header_params=None, - body=None, post_params=None, files=None, - response_type=None, auth_settings=None, async=None, - _return_http_data_only=None, collection_formats=None, - _preload_content=True, _request_timeout=None): - """Makes the HTTP request (synchronous) and returns deserialized data. - - To make an async request, set the async parameter. - - :param resource_path: Path to method endpoint. - :param method: Method to call. - :param path_params: Path parameters in the url. - :param query_params: Query parameters in the url. - :param header_params: Header parameters to be - placed in the request header. - :param body: Request body. - :param post_params dict: Request post form parameters, - for `application/x-www-form-urlencoded`, `multipart/form-data`. - :param auth_settings list: Auth Settings names for the request. - :param response: Response data type. - :param files dict: key -> filename, value -> filepath, - for `multipart/form-data`. - :param async bool: execute request asynchronously - :param _return_http_data_only: response data without head status code - and headers - :param collection_formats: dict of collection formats for path, query, - header, and post parameters. - :param _preload_content: if False, the urllib3.HTTPResponse object will - be returned without reading/decoding response - data. Default is True. - :param _request_timeout: timeout setting for this request. If one - number provided, it will be total request - timeout. It can also be a pair (tuple) of - (connection, read) timeouts. - :return: - If async parameter is True, - the request will be called asynchronously. - The method will return the request thread. - If parameter async is False or missing, - then the method will return the response directly. - """ - if not async: - return self.__call_api(resource_path, method, - path_params, query_params, header_params, - body, post_params, files, - response_type, auth_settings, - _return_http_data_only, collection_formats, - _preload_content, _request_timeout) - else: - thread = self.pool.apply_async(self.__call_api, (resource_path, - method, path_params, query_params, - header_params, body, - post_params, files, - response_type, auth_settings, - _return_http_data_only, - collection_formats, - _preload_content, _request_timeout)) - return thread - - def request(self, method, url, query_params=None, headers=None, - post_params=None, body=None, _preload_content=True, - _request_timeout=None): - """Makes the HTTP request using RESTClient.""" - if method == "GET": - return self.rest_client.GET(url, - query_params=query_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - headers=headers) - elif method == "HEAD": - return self.rest_client.HEAD(url, - query_params=query_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - headers=headers) - elif method == "OPTIONS": - return self.rest_client.OPTIONS(url, - query_params=query_params, - headers=headers, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - elif method == "POST": - return self.rest_client.POST(url, - query_params=query_params, - headers=headers, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - elif method == "PUT": - return self.rest_client.PUT(url, - query_params=query_params, - headers=headers, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - elif method == "PATCH": - return self.rest_client.PATCH(url, - query_params=query_params, - headers=headers, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - elif method == "DELETE": - return self.rest_client.DELETE(url, - query_params=query_params, - headers=headers, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - else: - raise ValueError( - "http method must be `GET`, `HEAD`, `OPTIONS`," - " `POST`, `PATCH`, `PUT` or `DELETE`." - ) - - def parameters_to_tuples(self, params, collection_formats): - """Get parameters as list of tuples, formatting collections. - - :param params: Parameters as dict or list of two-tuples - :param dict collection_formats: Parameter collection formats - :return: Parameters as list of tuples, collections formatted - """ - new_params = [] - if collection_formats is None: - collection_formats = {} - for k, v in six.iteritems(params) if isinstance(params, dict) else params: # noqa: E501 - if k in collection_formats: - collection_format = collection_formats[k] - if collection_format == 'multi': - new_params.extend((k, value) for value in v) - else: - if collection_format == 'ssv': - delimiter = ' ' - elif collection_format == 'tsv': - delimiter = '\t' - elif collection_format == 'pipes': - delimiter = '|' - else: # csv is the default - delimiter = ',' - new_params.append( - (k, delimiter.join(str(value) for value in v))) - else: - new_params.append((k, v)) - return new_params - - def prepare_post_parameters(self, post_params=None, files=None): - """Builds form parameters. - - :param post_params: Normal form parameters. - :param files: File parameters. - :return: Form parameters with files. - """ - params = [] - - if post_params: - params = post_params - - if files: - for k, v in six.iteritems(files): - if not v: - continue - file_names = v if type(v) is list else [v] - for n in file_names: - with open(n, 'rb') as f: - filename = os.path.basename(f.name) - filedata = f.read() - mimetype = (mimetypes.guess_type(filename)[0] or - 'application/octet-stream') - params.append( - tuple([k, tuple([filename, filedata, mimetype])])) - - return params - - def select_header_accept(self, accepts): - """Returns `Accept` based on an array of accepts provided. - - :param accepts: List of headers. - :return: Accept (e.g. application/json). - """ - if not accepts: - return - - accepts = [x.lower() for x in accepts] - - if 'application/json' in accepts: - return 'application/json' - else: - return ', '.join(accepts) - - def select_header_content_type(self, content_types): - """Returns `Content-Type` based on an array of content_types provided. - - :param content_types: List of content-types. - :return: Content-Type (e.g. application/json). - """ - if not content_types: - return 'application/json' - - content_types = [x.lower() for x in content_types] - - if 'application/json' in content_types or '*/*' in content_types: - return 'application/json' - else: - return content_types[0] - - def update_params_for_auth(self, headers, querys, auth_settings): - """Updates header and query params based on authentication setting. - - :param headers: Header parameters dict to be updated. - :param querys: Query parameters tuple list to be updated. - :param auth_settings: Authentication setting identifiers list. - """ - if not auth_settings: - return - - for auth in auth_settings: - auth_setting = self.configuration.auth_settings().get(auth) - if auth_setting: - if not auth_setting['value']: - continue - elif auth_setting['in'] == 'header': - headers[auth_setting['key']] = auth_setting['value'] - elif auth_setting['in'] == 'query': - querys.append((auth_setting['key'], auth_setting['value'])) - else: - raise ValueError( - 'Authentication token must be in `query` or `header`' - ) - - def __deserialize_file(self, response): - """Deserializes body to file - - Saves response body into a file in a temporary folder, - using the filename from the `Content-Disposition` header if provided. - - :param response: RESTResponse. - :return: file path. - """ - fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) - os.close(fd) - os.remove(path) - - content_disposition = response.getheader("Content-Disposition") - if content_disposition: - filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', - content_disposition).group(1) - path = os.path.join(os.path.dirname(path), filename) - - with open(path, "wb") as f: - f.write(response.data) - - return path - - def __deserialize_primitive(self, data, klass): - """Deserializes string to primitive type. - - :param data: str. - :param klass: class literal. - - :return: int, long, float, str, bool. - """ - try: - return klass(data) - except UnicodeEncodeError: - return six.u(data) - except TypeError: - return data - - def __deserialize_object(self, value): - """Return a original value. - - :return: object. - """ - return value - - def __deserialize_date(self, string): - """Deserializes string to date. - - :param string: str. - :return: date. - """ - try: - from dateutil.parser import parse - return parse(string).date() - except ImportError: - return string - except ValueError: - raise rest.ApiException( - status=0, - reason="Failed to parse `{0}` as date object".format(string) - ) - - def __deserialize_datatime(self, string): - """Deserializes string to datetime. - - The string should be in iso8601 datetime format. - - :param string: str. - :return: datetime. - """ - try: - from dateutil.parser import parse - return parse(string) - except ImportError: - return string - except ValueError: - raise rest.ApiException( - status=0, - reason=( - "Failed to parse `{0}` as datetime object" - .format(string) - ) - ) - - def __deserialize_model(self, data, klass): - """Deserializes list or dict to model. - - :param data: dict, list. - :param klass: class literal. - :return: model object. - """ - - if not klass.swagger_types and not hasattr(klass, - 'get_real_child_model'): - return data - - kwargs = {} - if klass.swagger_types is not None: - for attr, attr_type in six.iteritems(klass.swagger_types): - if (data is not None and - klass.attribute_map[attr] in data and - isinstance(data, (list, dict))): - value = data[klass.attribute_map[attr]] - kwargs[attr] = self.__deserialize(value, attr_type) - - instance = klass(**kwargs) - - if hasattr(instance, 'get_real_child_model'): - klass_name = instance.get_real_child_model(data) - if klass_name: - instance = self.__deserialize(data, klass_name) - return instance diff --git a/skycoin/restapi/configuration.py b/skycoin/restapi/configuration.py deleted file mode 100644 index 4597667f..00000000 --- a/skycoin/restapi/configuration.py +++ /dev/null @@ -1,246 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import copy -import logging -import multiprocessing -import sys -import urllib3 - -import six -from six.moves import http_client as httplib - - -class TypeWithDefault(type): - def __init__(cls, name, bases, dct): - super(TypeWithDefault, cls).__init__(name, bases, dct) - cls._default = None - - def __call__(cls): - if cls._default is None: - cls._default = type.__call__(cls) - return copy.copy(cls._default) - - def set_default(cls, default): - cls._default = copy.copy(default) - - -class Configuration(six.with_metaclass(TypeWithDefault, object)): - """NOTE: This class is auto generated by the swagger code generator program. - - Ref: https://github.com/swagger-api/swagger-codegen - Do not edit the class manually. - """ - - def __init__(self): - """Constructor""" - # Default Base url - self.host = "http://staging.node.skycoin.net" - # Temp file folder for downloading files - self.temp_folder_path = None - - # Authentication Settings - # dict to store API key(s) - self.api_key = {} - # dict to store API prefix (e.g. Bearer) - self.api_key_prefix = {} - # Username for HTTP basic authentication - self.username = "" - # Password for HTTP basic authentication - self.password = "" - - # Logging Settings - self.logger = {} - self.logger["package_logger"] = logging.getLogger("swagger_client") - self.logger["urllib3_logger"] = logging.getLogger("urllib3") - # Log format - self.logger_format = '%(asctime)s %(levelname)s %(message)s' - # Log stream handler - self.logger_stream_handler = None - # Log file handler - self.logger_file_handler = None - # Debug file location - self.logger_file = None - # Debug switch - self.debug = False - - # SSL/TLS verification - # Set this to false to skip verifying SSL certificate when calling API - # from https server. - self.verify_ssl = True - # Set this to customize the certificate file to verify the peer. - self.ssl_ca_cert = None - # client certificate file - self.cert_file = None - # client key file - self.key_file = None - # Set this to True/False to enable/disable SSL hostname verification. - self.assert_hostname = None - - # urllib3 connection pool's maximum number of connections saved - # per pool. urllib3 uses 1 connection as default value, but this is - # not the best value when you are making a lot of possibly parallel - # requests to the same host, which is often the case here. - # cpu_count * 5 is used as default value to increase performance. - self.connection_pool_maxsize = multiprocessing.cpu_count() * 5 - - # Proxy URL - self.proxy = None - # Safe chars for path_param - self.safe_chars_for_path_param = '' - - @property - def logger_file(self): - """The logger file. - - If the logger_file is None, then add stream handler and remove file - handler. Otherwise, add file handler and remove stream handler. - - :param value: The logger_file path. - :type: str - """ - return self.__logger_file - - @logger_file.setter - def logger_file(self, value): - """The logger file. - - If the logger_file is None, then add stream handler and remove file - handler. Otherwise, add file handler and remove stream handler. - - :param value: The logger_file path. - :type: str - """ - self.__logger_file = value - if self.__logger_file: - # If set logging file, - # then add file handler and remove stream handler. - self.logger_file_handler = logging.FileHandler(self.__logger_file) - self.logger_file_handler.setFormatter(self.logger_formatter) - for _, logger in six.iteritems(self.logger): - logger.addHandler(self.logger_file_handler) - if self.logger_stream_handler: - logger.removeHandler(self.logger_stream_handler) - else: - # If not set logging file, - # then add stream handler and remove file handler. - self.logger_stream_handler = logging.StreamHandler() - self.logger_stream_handler.setFormatter(self.logger_formatter) - for _, logger in six.iteritems(self.logger): - logger.addHandler(self.logger_stream_handler) - if self.logger_file_handler: - logger.removeHandler(self.logger_file_handler) - - @property - def debug(self): - """Debug status - - :param value: The debug status, True or False. - :type: bool - """ - return self.__debug - - @debug.setter - def debug(self, value): - """Debug status - - :param value: The debug status, True or False. - :type: bool - """ - self.__debug = value - if self.__debug: - # if debug status is True, turn on debug logging - for _, logger in six.iteritems(self.logger): - logger.setLevel(logging.DEBUG) - # turn on httplib debug - httplib.HTTPConnection.debuglevel = 1 - else: - # if debug status is False, turn off debug logging, - # setting log level to default `logging.WARNING` - for _, logger in six.iteritems(self.logger): - logger.setLevel(logging.WARNING) - # turn off httplib debug - httplib.HTTPConnection.debuglevel = 0 - - @property - def logger_format(self): - """The logger format. - - The logger_formatter will be updated when sets logger_format. - - :param value: The format string. - :type: str - """ - return self.__logger_format - - @logger_format.setter - def logger_format(self, value): - """The logger format. - - The logger_formatter will be updated when sets logger_format. - - :param value: The format string. - :type: str - """ - self.__logger_format = value - self.logger_formatter = logging.Formatter(self.__logger_format) - - def get_api_key_with_prefix(self, identifier): - """Gets API key (with prefix if set). - - :param identifier: The identifier of apiKey. - :return: The token for api key authentication. - """ - if (self.api_key.get(identifier) and - self.api_key_prefix.get(identifier)): - return self.api_key_prefix[identifier] + ' ' + self.api_key[identifier] # noqa: E501 - elif self.api_key.get(identifier): - return self.api_key[identifier] - - def get_basic_auth_token(self): - """Gets HTTP basic authentication header (string). - - :return: The token for basic HTTP authentication. - """ - return urllib3.util.make_headers( - basic_auth=self.username + ':' + self.password - ).get('authorization') - - def auth_settings(self): - """Gets Auth Settings dict for api client. - - :return: The Auth Settings information dict. - """ - return { - 'csrfAuth': - { - 'type': 'api_key', - 'in': 'header', - 'key': 'csrf_Token', - 'value': self.get_api_key_with_prefix('csrf_Token') - }, - - } - - def to_debug_report(self): - """Gets the essential information for debugging. - - :return: The report for debugging. - """ - return "Python SDK Debug Report:\n"\ - "OS: {env}\n"\ - "Python Version: {pyversion}\n"\ - "Version of the API: 1.0.0\n"\ - "SDK Package Version: 1.0.0".\ - format(env=sys.platform, pyversion=sys.version) diff --git a/skycoin/restapi/models/__init__.py b/skycoin/restapi/models/__init__.py deleted file mode 100644 index 46ba4cd9..00000000 --- a/skycoin/restapi/models/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -# coding: utf-8 - -# flake8: noqa -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -# import models into model package -from swagger_client.models.build_info import BuildInfo -from swagger_client.models.inline_response_200 import InlineResponse200 -from swagger_client.models.inline_response_422 import InlineResponse422 -from swagger_client.models.inline_response_default import InlineResponseDefault diff --git a/skycoin/restapi/models/build_info.py b/skycoin/restapi/models/build_info.py deleted file mode 100644 index 1bbbbf2f..00000000 --- a/skycoin/restapi/models/build_info.py +++ /dev/null @@ -1,169 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -import pprint -import re # noqa: F401 - -import six - - -class BuildInfo(object): - """NOTE: This class is auto generated by the swagger code generator program. - - Do not edit the class manually. - """ - - """ - Attributes: - swagger_types (dict): The key is attribute name - and the value is attribute type. - attribute_map (dict): The key is attribute name - and the value is json key in definition. - """ - swagger_types = { - 'branch': 'str', - 'commit': 'str', - 'version': 'str' - } - - attribute_map = { - 'branch': 'branch', - 'commit': 'commit', - 'version': 'version' - } - - def __init__(self, branch=None, commit=None, version=None): # noqa: E501 - """BuildInfo - a model defined in Swagger""" # noqa: E501 - - self._branch = None - self._commit = None - self._version = None - self.discriminator = None - - if branch is not None: - self.branch = branch - if commit is not None: - self.commit = commit - if version is not None: - self.version = version - - @property - def branch(self): - """Gets the branch of this BuildInfo. # noqa: E501 - - git branch name # noqa: E501 - - :return: The branch of this BuildInfo. # noqa: E501 - :rtype: str - """ - return self._branch - - @branch.setter - def branch(self, branch): - """Sets the branch of this BuildInfo. - - git branch name # noqa: E501 - - :param branch: The branch of this BuildInfo. # noqa: E501 - :type: str - """ - - self._branch = branch - - @property - def commit(self): - """Gets the commit of this BuildInfo. # noqa: E501 - - git commit id # noqa: E501 - - :return: The commit of this BuildInfo. # noqa: E501 - :rtype: str - """ - return self._commit - - @commit.setter - def commit(self, commit): - """Sets the commit of this BuildInfo. - - git commit id # noqa: E501 - - :param commit: The commit of this BuildInfo. # noqa: E501 - :type: str - """ - - self._commit = commit - - @property - def version(self): - """Gets the version of this BuildInfo. # noqa: E501 - - version number # noqa: E501 - - :return: The version of this BuildInfo. # noqa: E501 - :rtype: str - """ - return self._version - - @version.setter - def version(self, version): - """Sets the version of this BuildInfo. - - version number # noqa: E501 - - :param version: The version of this BuildInfo. # noqa: E501 - :type: str - """ - - self._version = version - - def to_dict(self): - """Returns the model properties as a dict""" - result = {} - - for attr, _ in six.iteritems(self.swagger_types): - value = getattr(self, attr) - if isinstance(value, list): - result[attr] = list(map( - lambda x: x.to_dict() if hasattr(x, "to_dict") else x, - value - )) - elif hasattr(value, "to_dict"): - result[attr] = value.to_dict() - elif isinstance(value, dict): - result[attr] = dict(map( - lambda item: (item[0], item[1].to_dict()) - if hasattr(item[1], "to_dict") else item, - value.items() - )) - else: - result[attr] = value - - return result - - def to_str(self): - """Returns the string representation of the model""" - return pprint.pformat(self.to_dict()) - - def __repr__(self): - """For `print` and `pprint`""" - return self.to_str() - - def __eq__(self, other): - """Returns true if both objects are equal""" - if not isinstance(other, BuildInfo): - return False - - return self.__dict__ == other.__dict__ - - def __ne__(self, other): - """Returns true if both objects are not equal""" - return not self == other diff --git a/skycoin/restapi/models/inline_response_200.py b/skycoin/restapi/models/inline_response_200.py deleted file mode 100644 index 8c240a5a..00000000 --- a/skycoin/restapi/models/inline_response_200.py +++ /dev/null @@ -1,113 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -import pprint -import re # noqa: F401 - -import six - - -class InlineResponse200(object): - """NOTE: This class is auto generated by the swagger code generator program. - - Do not edit the class manually. - """ - - """ - Attributes: - swagger_types (dict): The key is attribute name - and the value is attribute type. - attribute_map (dict): The key is attribute name - and the value is json key in definition. - """ - swagger_types = { - 'csrf_token': 'str' - } - - attribute_map = { - 'csrf_token': 'csrf_token' - } - - def __init__(self, csrf_token=None): # noqa: E501 - """InlineResponse200 - a model defined in Swagger""" # noqa: E501 - - self._csrf_token = None - self.discriminator = None - - if csrf_token is not None: - self.csrf_token = csrf_token - - @property - def csrf_token(self): - """Gets the csrf_token of this InlineResponse200. # noqa: E501 - - Csrf Token is here # noqa: E501 - - :return: The csrf_token of this InlineResponse200. # noqa: E501 - :rtype: str - """ - return self._csrf_token - - @csrf_token.setter - def csrf_token(self, csrf_token): - """Sets the csrf_token of this InlineResponse200. - - Csrf Token is here # noqa: E501 - - :param csrf_token: The csrf_token of this InlineResponse200. # noqa: E501 - :type: str - """ - - self._csrf_token = csrf_token - - def to_dict(self): - """Returns the model properties as a dict""" - result = {} - - for attr, _ in six.iteritems(self.swagger_types): - value = getattr(self, attr) - if isinstance(value, list): - result[attr] = list(map( - lambda x: x.to_dict() if hasattr(x, "to_dict") else x, - value - )) - elif hasattr(value, "to_dict"): - result[attr] = value.to_dict() - elif isinstance(value, dict): - result[attr] = dict(map( - lambda item: (item[0], item[1].to_dict()) - if hasattr(item[1], "to_dict") else item, - value.items() - )) - else: - result[attr] = value - - return result - - def to_str(self): - """Returns the string representation of the model""" - return pprint.pformat(self.to_dict()) - - def __repr__(self): - """For `print` and `pprint`""" - return self.to_str() - - def __eq__(self, other): - """Returns true if both objects are equal""" - if not isinstance(other, InlineResponse200): - return False - - return self.__dict__ == other.__dict__ - - def __ne__(self, other): - """Returns true if both objects are not equal""" - return not self == other diff --git a/skycoin/restapi/models/inline_response_422.py b/skycoin/restapi/models/inline_response_422.py deleted file mode 100644 index 9c1637ef..00000000 --- a/skycoin/restapi/models/inline_response_422.py +++ /dev/null @@ -1,163 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -import pprint -import re # noqa: F401 - -import six - - -class InlineResponse422(object): - """NOTE: This class is auto generated by the swagger code generator program. - - Do not edit the class manually. - """ - - """ - Attributes: - swagger_types (dict): The key is attribute name - and the value is attribute type. - attribute_map (dict): The key is attribute name - and the value is json key in definition. - """ - swagger_types = { - 'code': 'int', - 'field': 'str', - 'message': 'str' - } - - attribute_map = { - 'code': 'code', - 'field': 'field', - 'message': 'message' - } - - def __init__(self, code=None, field=None, message=None): # noqa: E501 - """InlineResponse422 - a model defined in Swagger""" # noqa: E501 - - self._code = None - self._field = None - self._message = None - self.discriminator = None - - if code is not None: - self.code = code - if field is not None: - self.field = field - if message is not None: - self.message = message - - @property - def code(self): - """Gets the code of this InlineResponse422. # noqa: E501 - - - :return: The code of this InlineResponse422. # noqa: E501 - :rtype: int - """ - return self._code - - @code.setter - def code(self, code): - """Sets the code of this InlineResponse422. - - - :param code: The code of this InlineResponse422. # noqa: E501 - :type: int - """ - - self._code = code - - @property - def field(self): - """Gets the field of this InlineResponse422. # noqa: E501 - - - :return: The field of this InlineResponse422. # noqa: E501 - :rtype: str - """ - return self._field - - @field.setter - def field(self, field): - """Sets the field of this InlineResponse422. - - - :param field: The field of this InlineResponse422. # noqa: E501 - :type: str - """ - - self._field = field - - @property - def message(self): - """Gets the message of this InlineResponse422. # noqa: E501 - - - :return: The message of this InlineResponse422. # noqa: E501 - :rtype: str - """ - return self._message - - @message.setter - def message(self, message): - """Sets the message of this InlineResponse422. - - - :param message: The message of this InlineResponse422. # noqa: E501 - :type: str - """ - - self._message = message - - def to_dict(self): - """Returns the model properties as a dict""" - result = {} - - for attr, _ in six.iteritems(self.swagger_types): - value = getattr(self, attr) - if isinstance(value, list): - result[attr] = list(map( - lambda x: x.to_dict() if hasattr(x, "to_dict") else x, - value - )) - elif hasattr(value, "to_dict"): - result[attr] = value.to_dict() - elif isinstance(value, dict): - result[attr] = dict(map( - lambda item: (item[0], item[1].to_dict()) - if hasattr(item[1], "to_dict") else item, - value.items() - )) - else: - result[attr] = value - - return result - - def to_str(self): - """Returns the string representation of the model""" - return pprint.pformat(self.to_dict()) - - def __repr__(self): - """For `print` and `pprint`""" - return self.to_str() - - def __eq__(self, other): - """Returns true if both objects are equal""" - if not isinstance(other, InlineResponse422): - return False - - return self.__dict__ == other.__dict__ - - def __ne__(self, other): - """Returns true if both objects are not equal""" - return not self == other diff --git a/skycoin/restapi/models/inline_response_default.py b/skycoin/restapi/models/inline_response_default.py deleted file mode 100644 index 10e94157..00000000 --- a/skycoin/restapi/models/inline_response_default.py +++ /dev/null @@ -1,137 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -import pprint -import re # noqa: F401 - -import six - - -class InlineResponseDefault(object): - """NOTE: This class is auto generated by the swagger code generator program. - - Do not edit the class manually. - """ - - """ - Attributes: - swagger_types (dict): The key is attribute name - and the value is attribute type. - attribute_map (dict): The key is attribute name - and the value is json key in definition. - """ - swagger_types = { - 'code': 'int', - 'message': 'str' - } - - attribute_map = { - 'code': 'code', - 'message': 'message' - } - - def __init__(self, code=None, message=None): # noqa: E501 - """InlineResponseDefault - a model defined in Swagger""" # noqa: E501 - - self._code = None - self._message = None - self.discriminator = None - - if code is not None: - self.code = code - if message is not None: - self.message = message - - @property - def code(self): - """Gets the code of this InlineResponseDefault. # noqa: E501 - - - :return: The code of this InlineResponseDefault. # noqa: E501 - :rtype: int - """ - return self._code - - @code.setter - def code(self, code): - """Sets the code of this InlineResponseDefault. - - - :param code: The code of this InlineResponseDefault. # noqa: E501 - :type: int - """ - - self._code = code - - @property - def message(self): - """Gets the message of this InlineResponseDefault. # noqa: E501 - - - :return: The message of this InlineResponseDefault. # noqa: E501 - :rtype: str - """ - return self._message - - @message.setter - def message(self, message): - """Sets the message of this InlineResponseDefault. - - - :param message: The message of this InlineResponseDefault. # noqa: E501 - :type: str - """ - - self._message = message - - def to_dict(self): - """Returns the model properties as a dict""" - result = {} - - for attr, _ in six.iteritems(self.swagger_types): - value = getattr(self, attr) - if isinstance(value, list): - result[attr] = list(map( - lambda x: x.to_dict() if hasattr(x, "to_dict") else x, - value - )) - elif hasattr(value, "to_dict"): - result[attr] = value.to_dict() - elif isinstance(value, dict): - result[attr] = dict(map( - lambda item: (item[0], item[1].to_dict()) - if hasattr(item[1], "to_dict") else item, - value.items() - )) - else: - result[attr] = value - - return result - - def to_str(self): - """Returns the string representation of the model""" - return pprint.pformat(self.to_dict()) - - def __repr__(self): - """For `print` and `pprint`""" - return self.to_str() - - def __eq__(self, other): - """Returns true if both objects are equal""" - if not isinstance(other, InlineResponseDefault): - return False - - return self.__dict__ == other.__dict__ - - def __ne__(self, other): - """Returns true if both objects are not equal""" - return not self == other diff --git a/skycoin/restapi/rest.py b/skycoin/restapi/rest.py deleted file mode 100644 index ed2892c0..00000000 --- a/skycoin/restapi/rest.py +++ /dev/null @@ -1,322 +0,0 @@ -# coding: utf-8 - -""" - - No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 - - OpenAPI spec version: 1.0.0 - Contact: contact@skycoin.net - Generated by: https://github.com/swagger-api/swagger-codegen.git -""" - - -from __future__ import absolute_import - -import io -import json -import logging -import re -import ssl - -import certifi -# python 2 and python 3 compatibility library -import six -from six.moves.urllib.parse import urlencode - -try: - import urllib3 -except ImportError: - raise ImportError('Swagger python client requires urllib3.') - - -logger = logging.getLogger(__name__) - - -class RESTResponse(io.IOBase): - - def __init__(self, resp): - self.urllib3_response = resp - self.status = resp.status - self.reason = resp.reason - self.data = resp.data - - def getheaders(self): - """Returns a dictionary of the response headers.""" - return self.urllib3_response.getheaders() - - def getheader(self, name, default=None): - """Returns a given response header.""" - return self.urllib3_response.getheader(name, default) - - -class RESTClientObject(object): - - def __init__(self, configuration, pools_size=4, maxsize=None): - # urllib3.PoolManager will pass all kw parameters to connectionpool - # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 - # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 - # maxsize is the number of requests to host that are allowed in parallel # noqa: E501 - # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 - - # cert_reqs - if configuration.verify_ssl: - cert_reqs = ssl.CERT_REQUIRED - else: - cert_reqs = ssl.CERT_NONE - - # ca_certs - if configuration.ssl_ca_cert: - ca_certs = configuration.ssl_ca_cert - else: - # if not set certificate file, use Mozilla's root certificates. - ca_certs = certifi.where() - - addition_pool_args = {} - if configuration.assert_hostname is not None: - addition_pool_args['assert_hostname'] = configuration.assert_hostname # noqa: E501 - - if maxsize is None: - if configuration.connection_pool_maxsize is not None: - maxsize = configuration.connection_pool_maxsize - else: - maxsize = 4 - - # https pool manager - if configuration.proxy: - self.pool_manager = urllib3.ProxyManager( - num_pools=pools_size, - maxsize=maxsize, - cert_reqs=cert_reqs, - ca_certs=ca_certs, - cert_file=configuration.cert_file, - key_file=configuration.key_file, - proxy_url=configuration.proxy, - **addition_pool_args - ) - else: - self.pool_manager = urllib3.PoolManager( - num_pools=pools_size, - maxsize=maxsize, - cert_reqs=cert_reqs, - ca_certs=ca_certs, - cert_file=configuration.cert_file, - key_file=configuration.key_file, - **addition_pool_args - ) - - def request(self, method, url, query_params=None, headers=None, - body=None, post_params=None, _preload_content=True, - _request_timeout=None): - """Perform requests. - - :param method: http request method - :param url: http request url - :param query_params: query parameters in the url - :param headers: http request headers - :param body: request json body, for `application/json` - :param post_params: request post parameters, - `application/x-www-form-urlencoded` - and `multipart/form-data` - :param _preload_content: if False, the urllib3.HTTPResponse object will - be returned without reading/decoding response - data. Default is True. - :param _request_timeout: timeout setting for this request. If one - number provided, it will be total request - timeout. It can also be a pair (tuple) of - (connection, read) timeouts. - """ - method = method.upper() - assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT', - 'PATCH', 'OPTIONS'] - - if post_params and body: - raise ValueError( - "body parameter cannot be used with post_params parameter." - ) - - post_params = post_params or {} - headers = headers or {} - - timeout = None - if _request_timeout: - if isinstance(_request_timeout, (int, ) if six.PY3 else (int, long)): # noqa: E501,F821 - timeout = urllib3.Timeout(total=_request_timeout) - elif (isinstance(_request_timeout, tuple) and - len(_request_timeout) == 2): - timeout = urllib3.Timeout( - connect=_request_timeout[0], read=_request_timeout[1]) - - if 'Content-Type' not in headers: - headers['Content-Type'] = 'application/json' - - try: - # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` - if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: - if query_params: - url += '?' + urlencode(query_params) - if re.search('json', headers['Content-Type'], re.IGNORECASE): - request_body = None - if body is not None: - request_body = json.dumps(body) - r = self.pool_manager.request( - method, url, - body=request_body, - preload_content=_preload_content, - timeout=timeout, - headers=headers) - elif headers['Content-Type'] == 'application/x-www-form-urlencoded': # noqa: E501 - r = self.pool_manager.request( - method, url, - fields=post_params, - encode_multipart=False, - preload_content=_preload_content, - timeout=timeout, - headers=headers) - elif headers['Content-Type'] == 'multipart/form-data': - # must del headers['Content-Type'], or the correct - # Content-Type which generated by urllib3 will be - # overwritten. - del headers['Content-Type'] - r = self.pool_manager.request( - method, url, - fields=post_params, - encode_multipart=True, - preload_content=_preload_content, - timeout=timeout, - headers=headers) - # Pass a `string` parameter directly in the body to support - # other content types than Json when `body` argument is - # provided in serialized form - elif isinstance(body, str): - request_body = body - r = self.pool_manager.request( - method, url, - body=request_body, - preload_content=_preload_content, - timeout=timeout, - headers=headers) - else: - # Cannot generate the request from given parameters - msg = """Cannot prepare a request message for provided - arguments. Please check that your arguments match - declared content type.""" - raise ApiException(status=0, reason=msg) - # For `GET`, `HEAD` - else: - r = self.pool_manager.request(method, url, - fields=query_params, - preload_content=_preload_content, - timeout=timeout, - headers=headers) - except urllib3.exceptions.SSLError as e: - msg = "{0}\n{1}".format(type(e).__name__, str(e)) - raise ApiException(status=0, reason=msg) - - if _preload_content: - r = RESTResponse(r) - - # In the python 3, the response.data is bytes. - # we need to decode it to string. - if six.PY3: - r.data = r.data.decode('utf8') - - # log response body - logger.debug("response body: %s", r.data) - - if not 200 <= r.status <= 299: - raise ApiException(http_resp=r) - - return r - - def GET(self, url, headers=None, query_params=None, _preload_content=True, - _request_timeout=None): - return self.request("GET", url, - headers=headers, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - query_params=query_params) - - def HEAD(self, url, headers=None, query_params=None, _preload_content=True, - _request_timeout=None): - return self.request("HEAD", url, - headers=headers, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - query_params=query_params) - - def OPTIONS(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None): - return self.request("OPTIONS", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - - def DELETE(self, url, headers=None, query_params=None, body=None, - _preload_content=True, _request_timeout=None): - return self.request("DELETE", url, - headers=headers, - query_params=query_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - - def POST(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None): - return self.request("POST", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - - def PUT(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None): - return self.request("PUT", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - - def PATCH(self, url, headers=None, query_params=None, post_params=None, - body=None, _preload_content=True, _request_timeout=None): - return self.request("PATCH", url, - headers=headers, - query_params=query_params, - post_params=post_params, - _preload_content=_preload_content, - _request_timeout=_request_timeout, - body=body) - - -class ApiException(Exception): - - def __init__(self, status=None, reason=None, http_resp=None): - if http_resp: - self.status = http_resp.status - self.reason = http_resp.reason - self.body = http_resp.data - self.headers = http_resp.getheaders() - else: - self.status = status - self.reason = reason - self.body = None - self.headers = None - - def __str__(self): - """Custom error messages for exception""" - error_message = "({0})\n"\ - "Reason: {1}\n".format(self.status, self.reason) - if self.headers: - error_message += "HTTP response headers: {0}\n".format( - self.headers) - - if self.body: - error_message += "HTTP response body: {0}\n".format(self.body) - - return error_message