ots.h

Go to the documentation of this file.

#ifndef OTS_H
#define OTS_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "ots-errors.h"
 
/*******************************************************************************
 * Constants and Defines
 ******************************************************************************/
 
#define OTS_MAX_ERROR_MESSAGE 256
#define OTS_MAX_ERROR_LOCATION 64
#define OTS_MAX_VERSION_STRING 32
 
#define OTS_MONERO_SEED_WORDS 25
#define OTS_POLYSEED_WORDS 16
#define OTS_LEGACY_SEED_WORDS 13
 
#ifdef __cplusplus
extern "C" {
#endif
 
    typedef enum {
        OTS_NETWORK_MAIN,    
        OTS_NETWORK_TEST,    
        OTS_NETWORK_STAGE    
    } OTS_NETWORK;
 
    typedef enum {
        OTS_ADDRESS_TYPE_STANDARD,    
        OTS_ADDRESS_TYPE_SUBADDRESS,  
        OTS_ADDRESS_TYPE_INTEGRATED   
    } OTS_ADDRESS_TYPE;
 
    typedef enum {
        OTS_SEED_TYPE_MONERO,    
        OTS_SEED_TYPE_POLYSEED   
    } OTS_SEED_TYPE;
 
    typedef enum {
        OTS_HANDLE_INVALID = 0,
        OTS_HANDLE_SEED,
        OTS_HANDLE_WALLET,
        OTS_HANDLE_TX
    } ots_handle_type;
 
    typedef struct {
        ots_handle_type type;
        uint32_t version;
        void* ptr;
    } ots_handle_t;
 
    typedef struct {
        int32_t code;                                 
        char message[OTS_MAX_ERROR_MESSAGE];         
        char location[OTS_MAX_ERROR_LOCATION];       
    } ots_error_t;
 
    typedef struct {
        union {
            ots_handle_t handle;                     
            void* ptr;                               
            bool boolean;                            
            int64_t number;                          
        } result;
        ots_error_t error;                          
    } ots_result_t;
 
    typedef struct {
        char* data;                                  
        size_t length;                              
    } ots_wipeable_string_t;
 
    typedef struct {
        uint16_t* indices;                          
        size_t count;                               
    } ots_seed_indices_t;
 
    typedef struct {
        char* description;                          
        uint64_t amount;                           
        uint64_t fee;                              
        char* destination;                         
        uint32_t unlock_time;                      
    } ots_tx_description_t;
 
    typedef struct {
        char* message;                             
        uint32_t severity;                         
    } ots_tx_warning_t;
 
    static inline bool ots_handle_valid(ots_handle_t h, ots_handle_type expected) {
        return h.type == expected && h.ptr != NULL;
    }
 
    void ots_error_init(ots_error_t* error);
 
    bool ots_is_error(const ots_result_t* result);
 
    ots_result_t ots_get_last_error(void);
 
    ots_result_t ots_get_error_message(int32_t error_code);
 
    void ots_clear_error(void);
 
    bool ots_has_error(const ots_result_t* result);
 
    /*******************************************************************************
     * Memory Management Functions
     ******************************************************************************/
 
    void ots_wipeable_string_free(ots_wipeable_string_t* str);
 
    void ots_seed_indices_free(ots_seed_indices_t* indices);
 
    void ots_free_string(char* str);
 
    void ots_free_array(void* arr);
 
    void ots_free_handle(ots_handle_t handle);
 
    void ots_free_tx_description(ots_tx_description_t* desc);
 
    void ots_secure_free(void* buffer, size_t size);
 
    ots_result_t ots_wipeable_string_create(const char* str);
 
    ots_result_t ots_wipeable_string_compare(
            const ots_wipeable_string_t* str1,
            const ots_wipeable_string_t* str2
            );
 
    void ots_wipeable_string_clear(ots_wipeable_string_t* str);
 
    ots_result_t ots_seed_indices_create(size_t size);
 
    void ots_seed_indices_clear(ots_seed_indices_t* indices);
 
    ots_result_t ots_version(void);
 
    ots_result_t ots_version_components(void);
 
    /*******************************************************************************
     * Seed Management Functions
     ******************************************************************************/
 
    ots_result_t ots_seed_phrase(
            ots_handle_t handle,
            const char* language_code,
            const char* password
            );
 
    ots_result_t ots_seed_languages(OTS_SEED_TYPE type);
 
    ots_result_t ots_seed_indices(
            ots_handle_t handle,
            const char* password
            );
 
    ots_result_t ots_seed_fingerprint(ots_handle_t handle);
 
    ots_result_t ots_seed_address(ots_handle_t handle);
 
    ots_result_t ots_seed_timestamp(ots_handle_t handle);
 
    ots_result_t ots_seed_height(ots_handle_t handle);
 
    ots_result_t ots_seed_network(ots_handle_t handle);
 
    ots_result_t ots_seed_wallet(ots_handle_t handle);
 
    ots_result_t ots_seed_merge_values(
            const ots_seed_indices_t* values1,
            const ots_seed_indices_t* values2
            );
 
    ots_result_t ots_seed_merge_with_password(
            const char* password,
            const ots_seed_indices_t* values
            );
 
    ots_result_t ots_seed_merge_multiple_values(
            const ots_seed_indices_t* values[],
            size_t count
            );
 
    ots_result_t ots_seed_merge_values_and_zero(
            ots_seed_indices_t* values1,
            ots_seed_indices_t* values2,
            bool delete_after
            );
 
    ots_result_t ots_seed_merge_values_with_password_and_zero(
            char* password,
            ots_seed_indices_t* values,
            bool delete_after
            );
 
    ots_result_t ots_seed_merge_multiple_values_and_zero(
            ots_seed_indices_t* values[],
            size_t count,
            bool delete_after
            );
 
    /*******************************************************************************
     * Legacy Seed Functions
     ******************************************************************************/
 
    ots_result_t ots_legacy_seed_decode(
            const char* phrase,
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network
            );
 
    ots_result_t ots_legacy_seed_decode_indices(
            const ots_seed_indices_t* indices,
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network
            );
 
    /*******************************************************************************
     * Monero Seed Functions
     ******************************************************************************/
 
    ots_result_t ots_monero_seed_create(
            const uint8_t random[32],
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network
            );
 
    ots_result_t ots_monero_seed_generate(
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network
            );
 
    ots_result_t ots_monero_seed_decode(
            const char* phrase,
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network,
            const char* passphrase
            );
 
    ots_result_t ots_monero_seed_decode_indices(
            const ots_seed_indices_t* indices,
            uint64_t height,
            uint64_t time,
            OTS_NETWORK network,
            const char* passphrase
            );
 
    /*******************************************************************************
     * Polyseed Functions
     ******************************************************************************/
 
    ots_result_t ots_polyseed_create(
            const uint8_t random[19],
            OTS_NETWORK network,
            uint64_t time,
            const char* passphrase
            );
 
    ots_result_t ots_polyseed_generate(
            OTS_NETWORK network,
            uint64_t time,
            const char* passphrase
            );
 
    ots_result_t ots_polyseed_decode(
            const char* phrase,
            OTS_NETWORK network,
            const char* password,
            const char* passphrase
            );
 
    ots_result_t ots_polyseed_decode_indices(
            const ots_seed_indices_t* indices,
            OTS_NETWORK network,
            const char* password,
            const char* passphrase
            );
 
    ots_result_t ots_polyseed_decode_with_language(
            const char* phrase,
            const char* language_code,
            OTS_NETWORK network,
            const char* password,
            const char* passphrase
            );
 
    /*******************************************************************************
     * Address Management Functions
     ******************************************************************************/
 
    ots_result_t ots_address_type(ots_handle_t address);
 
    ots_result_t ots_address_network(ots_handle_t address);
 
    ots_result_t ots_address_fingerprint(ots_handle_t address);
 
    ots_result_t ots_address_is_integrated(ots_handle_t address);
 
    ots_result_t ots_address_payment_id(ots_handle_t address);
 
    ots_result_t ots_address_from_integrated(ots_handle_t address);
 
    ots_result_t ots_address_length(ots_handle_t address);
 
    ots_result_t ots_address_base58_string(ots_handle_t address_handle);
 
    ots_result_t ots_address_equal(
            ots_handle_t address1,
            ots_handle_t address2
            );
 
    ots_result_t ots_address_equal_string(
            ots_handle_t address_handle,
            const char* address_string
            );
 
    ots_result_t ots_address_create(const char* address);
 
    void ots_address_free(ots_handle_t handle);
 
    ots_result_t ots_address_string_valid(const char* address, OTS_NETWORK network);
 
    ots_result_t ots_address_string_network(const char* address);
 
    ots_result_t ots_address_string_type(const char* address);
 
    ots_result_t ots_address_string_fingerprint(const char* address);
 
    ots_result_t ots_address_string_is_integrated(const char* address);
 
    ots_result_t ots_address_string_payment_id(const char* address);
 
    ots_result_t ots_address_string_integrated(const char* address);
 
 
    /*******************************************************************************
     * Wallet Functions
     ******************************************************************************/
 
    ots_result_t ots_wallet_create(
            const uint8_t key[32],
            uint64_t height,
            OTS_NETWORK network
            );
 
    ots_result_t ots_wallet_height(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_address(ots_handle_t wallet_handle, uint32_t account, uint32_t index);
 
    ots_result_t ots_wallet_accounts(
            ots_handle_t wallet_handle,
            uint32_t max,
            uint32_t offset
            );
 
    ots_result_t ots_wallet_subaddresses(
            ots_handle_t wallet_handle,
            uint32_t account,
            uint32_t max,
            uint32_t offset
            );
 
    ots_result_t ots_wallet_has_address(
            ots_handle_t wallet_handle,
            const char* address,
            uint32_t max_account_depth,
            uint32_t max_index_depth
            );
 
    ots_result_t ots_wallet_has_address_handle(
            ots_handle_t wallet_handle,
            ots_handle_t address_handle,
            uint32_t max_account_depth,
            uint32_t max_index_depth
            );
 
    ots_result_t ots_wallet_address_index(
            ots_handle_t wallet_handle,
            const char* address,
            uint32_t max_account_depth,
            uint32_t max_index_depth
            );
 
    ots_result_t ots_wallet_address_index_handle(
            ots_handle_t wallet_handle,
            ots_handle_t address_handle,
            uint32_t max_account_depth,
            uint32_t max_index_depth
            );
 
    ots_result_t ots_wallet_secret_view_key(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_public_view_key(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_secret_spend_key(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_public_spend_key(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_import_outputs(
            ots_handle_t wallet_handle,
            const char* outputs
            );
 
    ots_result_t ots_wallet_export_key_images(ots_handle_t wallet_handle);
 
    ots_result_t ots_wallet_describe_tx(ots_handle_t wallet_handle, const char* unsigned_tx);
 
    ots_result_t ots_wallet_check_tx(ots_handle_t wallet_handle, ots_handle_t unsigned_tx_handle);
 
    ots_result_t ots_wallet_check_tx_string(
            ots_handle_t wallet_handle,
            const char* unsigned_tx
            );
 
    ots_result_t ots_wallet_sign_transaction(
            ots_handle_t wallet_handle,
            const char* unsigned_tx
            );
 
    ots_result_t ots_wallet_sign_data(ots_handle_t wallet_handle, const char* data);
 
    ots_result_t ots_wallet_sign_data_with_index(
            ots_handle_t wallet_handle,
            const char* data,
            uint32_t account,
            uint32_t subaddr
            );
 
    ots_result_t ots_wallet_sign_data_with_address(
            ots_handle_t wallet_handle,
            const char* data,
            ots_handle_t address_handle
            );
 
    ots_result_t ots_wallet_verify_data(
            const char* data,
            const char* signature,
            bool legacy_fallback
            );
 
    ots_result_t ots_wallet_verify_data_with_index(
            ots_handle_t wallet_handle,
            const char* data,
            uint32_t account,
            uint32_t subaddr,
            const char* signature,
            bool legacy_fallback
            );
 
    ots_result_t ots_wallet_verify_data_with_address(
            ots_handle_t wallet_handle,
            const char* data,
            ots_handle_t address_handle,
            const char* signature,
            bool legacy_fallback
            );
 
    /*******************************************************************************
     * OTS Utility Functions
     ******************************************************************************/
 
    ots_result_t ots_height_from_timestamp(
            uint64_t timestamp,
            OTS_NETWORK network
            );
 
    ots_result_t ots_timestamp_from_height(
            uint64_t height,
            OTS_NETWORK network
            );
 
    ots_result_t ots_random_bytes(
            uint8_t* buffer,
            size_t size
            );
 
    ots_result_t ots_random_32(void);
 
    ots_result_t ots_check_entropy(
            const uint8_t* data,
            size_t size,
            double min_entropy
            );
 
    void ots_set_enforce_entropy(bool enforce);
 
    void ots_set_max_account_depth(uint32_t depth);
 
    void ots_set_max_index_depth(uint32_t depth);
 
    void ots_set_max_depth(uint32_t account_depth, uint32_t index_depth);
 
    void ots_reset_max_depth(void);
 
    uint32_t ots_max_account_depth(uint32_t depth);
 
    uint32_t ots_max_index_depth(uint32_t depth);
 
    ots_result_t ots_verify_data(const char* data, const char* address, const char* signature);
 
#ifdef __cplusplus
}
#endif
 
#endif // OTS_H