Merge branch 'develop' into 'master'

Develop

See merge request in3/c/in3-core!240

Author: simon-jentzsch

Diff for: c/docs/1_install.md

@@ -112,6 +112,13 @@ Default-Value: `-DEVM_GAS=ON`
 Default-Value: `-DFAST_MATH=OFF`
 
 
+#### GCC_ANALYZER
+
+  GCC10 static code analyses
+
+Default-Value: `-DGCC_ANALYZER=OFF`
+
+
 #### IN3API
 
   build the USN-API which offer better interfaces and additional functions on top of the pure verification
@@ -154,6 +161,13 @@ Default-Value: `-DIPFS=ON`
 Default-Value: `-DJAVA=OFF`
 
 
+#### LEDGER_NANO
+
+  include support for nano ledger
+
+Default-Value: `-DLEDGER_NANO=OFF`
+
+
 #### PAY_ETH
 
   support for direct Eth-Payment

Diff for: c/docs/2_examples.md

@@ -599,6 +599,64 @@ int main() {
 
 ```
 
+### ledger_sign
+
+source : [in3-c/c/examples/ledger_sign.c](https://github.com/slockit/in3-c/blob/master/c/examples/ledger_sign.c)
+
+
+
+```c
+
+#include <in3/client.h>        // the core client
+#include <in3/eth_api.h>       // functions for direct api-access
+#include <in3/in3_init.h>      // if included the verifier will automaticly be initialized.
+#include <in3/ledger_signer.h> //to invoke ledger nano device for signing
+#include <in3/log.h>           // logging functions
+#include <in3/utils.h>
+#include <stdio.h>
+
+static void send_tx_api(in3_t* in3);
+
+int main() {
+  // create new incubed client
+  uint8_t bip_path[5] = {44, 60, 0, 0, 0};
+  in3_t*  in3         = in3_for_chain(ETH_CHAIN_ID_MAINNET);
+  in3_log_set_level(LOG_DEBUG);
+  // setting ledger nano s to be the default signer for incubed client
+  // it will cause the transaction or any msg to be sent to ledger nanos device for siging
+  eth_ledger_set_signer(in3, bip_path);
+
+  // send tx using API
+  send_tx_api(in3);
+
+  // cleanup client after usage
+  in3_free(in3);
+}
+
+void send_tx_api(in3_t* in3) {
+  // prepare parameters
+  address_t to, from;
+  hex_to_bytes("0xC51fBbe0a68a7cA8d33f14a660126Da2A2FAF8bf", -1, from, 20);
+  hex_to_bytes("0xd46e8dd67c5d32be8058bb8eb970870f07244567", -1, to, 20);
+
+  bytes_t* data = hex_to_new_bytes("d46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675", 82);
+
+  // send the tx
+  bytes_t* tx_hash = eth_sendTransaction(in3, from, to, OPTIONAL_T_VALUE(uint64_t, 0x96c0), OPTIONAL_T_VALUE(uint64_t, 0x9184e72a000), OPTIONAL_T_VALUE(uint256_t, to_uint256(0x9184e72a)), OPTIONAL_T_VALUE(bytes_t, *data), OPTIONAL_T_UNDEFINED(uint64_t));
+
+  // if the result is null there was an error and we can get the latest error message from eth_last_error()
+  if (!tx_hash)
+    printf("error sending the tx : %s\n", eth_last_error());
+  else {
+    printf("Transaction hash: ");
+    b_print(tx_hash);
+    b_free(tx_hash);
+  }
+  b_free(data);
+}
+
+```
+
 ### send_transaction
 
 source : [in3-c/c/examples/send_transaction.c](https://github.com/slockit/in3-c/blob/master/c/examples/send_transaction.c)

Diff for: c/examples/README.md

@@ -22,6 +22,8 @@
 -  [ipfs_put_get](./ipfs_put_get.c)
     using the IPFS module
 
+-  [ledger_sign](./ledger_sign.c)
+   
 -  [send_transaction](./send_transaction.c)
    sending a transaction including signing it with a private key
 

Diff for: c/include/in3/data.h

@@ -104,19 +104,22 @@ typedef struct json_parser {
  * Objects or arrays will return 0x.
  */
 bytes_t                d_to_bytes(d_token_t* item);
-int                    d_bytes_to(d_token_t* item, uint8_t* dst, const int max);                                        /**< writes the byte-representation to the dst. details see d_to_bytes.*/
-bytes_t*               d_bytes(const d_token_t* item);                                                                  /**< returns the value as bytes (Carefully, make sure that the token is a bytes-type!)*/
-bytes_t*               d_bytesl(d_token_t* item, size_t l);                                                             /**< returns the value as bytes with length l (may reallocates) */
-char*                  d_string(const d_token_t* item);                                                                 /**< converts the value as string. Make sure the type is string! */
-int32_t                d_int(const d_token_t* item);                                                                    /**< returns the value as integer. only if type is integer */
-int32_t                d_intd(const d_token_t* item, const uint32_t def_val);                                           /**< returns the value as integer or if NULL the default. only if type is integer */
-uint64_t               d_long(const d_token_t* item);                                                                   /**< returns the value as long. only if type is integer or bytes, but short enough */
-uint64_t               d_longd(const d_token_t* item, const uint64_t def_val);                                          /**< returns the value as long or if NULL the default. only if type is integer or bytes, but short enough */
-bytes_t**              d_create_bytes_vec(const d_token_t* arr);                                                        /** creates a array of bytes from JOSN-array */
-static inline d_type_t d_type(const d_token_t* item) { return item == NULL ? T_NULL : (item->len & 0xF0000000) >> 28; } /**< type of the token */
-static inline int      d_len(const d_token_t* item) { return item == NULL ? 0 : item->len & 0xFFFFFFF; }                /**< number of elements in the token (only for object or array, other will return 0) */
-bool                   d_eq(const d_token_t* a, const d_token_t* b);                                                    /**< compares 2 token and if the value is equal */
-d_key_t                keyn(const char* c, const size_t len);                                                           /**< generates the keyhash for the given stringrange as defined by len */
+int                    d_bytes_to(d_token_t* item, uint8_t* dst, const int max);                                    /**< writes the byte-representation to the dst. details see d_to_bytes.*/
+bytes_t*               d_bytes(const d_token_t* item);                                                              /**< returns the value as bytes (Carefully, make sure that the token is a bytes-type!)*/
+bytes_t*               d_bytesl(d_token_t* item, size_t l);                                                         /**< returns the value as bytes with length l (may reallocates) */
+char*                  d_string(const d_token_t* item);                                                             /**< converts the value as string. Make sure the type is string! */
+int32_t                d_int(const d_token_t* item);                                                                /**< returns the value as integer. only if type is integer */
+int32_t                d_intd(const d_token_t* item, const uint32_t def_val);                                       /**< returns the value as integer or if NULL the default. only if type is integer */
+uint64_t               d_long(const d_token_t* item);                                                               /**< returns the value as long. only if type is integer or bytes, but short enough */
+uint64_t               d_longd(const d_token_t* item, const uint64_t def_val);                                      /**< returns the value as long or if NULL the default. only if type is integer or bytes, but short enough */
+bytes_t**              d_create_bytes_vec(const d_token_t* arr);                                                    /** creates a array of bytes from JOSN-array */
+static inline d_type_t d_type(const d_token_t* item) { return (item ? ((item->len & 0xF0000000) >> 28) : T_NULL); } /**< type of the token */
+static inline int      d_len(const d_token_t* item) {                                                               /**< number of elements in the token (only for object or array, other will return 0) */
+  if (item == NULL) return 0;
+  return item->len & 0xFFFFFFF;
+}
+bool    d_eq(const d_token_t* a, const d_token_t* b); /**< compares 2 token and if the value is equal */
+d_key_t keyn(const char* c, const size_t len);        /**< generates the keyhash for the given stringrange as defined by len */
 
 d_token_t* d_get(d_token_t* item, const uint16_t key);                          /**< returns the token with the given propertyname (only if item is a object) */
 d_token_t* d_get_or(d_token_t* item, const uint16_t key1, const uint16_t key2); /**< returns the token with the given propertyname or if not found, tries the other. (only if item is a object) */
@@ -191,8 +194,8 @@ typedef struct d_iterator {
   int        left;  /**< number of result left */
 } d_iterator_t;
 
-static inline d_iterator_t d_iter(d_token_t* parent) { return (d_iterator_t){.left = d_len(parent), .token = parent + 1}; } /**< creates a iterator for a object or array */
-static inline bool         d_iter_next(d_iterator_t* const iter) {
+d_iterator_t       d_iter(d_token_t* parent); /**< creates a iterator for a object or array */
+static inline bool d_iter_next(d_iterator_t* const iter) {
   iter->token = d_next(iter->token);
   return iter->left--;
 } /**< fetched the next token an returns a boolean indicating whther there is a next or not.*/

Diff for: c/include/in3/ledger_signer.h

@@ -45,5 +45,7 @@
 #include "client.h"
 
 in3_ret_t eth_ledger_set_signer(in3_t* in3, uint8_t* bip_path);
+in3_ret_t eth_ledger_get_public_key(uint8_t* i_bip_path, uint8_t* o_public_key);
+in3_ret_t eth_ledger_sign(void* ctx, d_signature_type_t type, bytes_t message, bytes_t account, uint8_t* dst);
 
 #endif