pyth version 2: aggregate price algo and up to 32 publishers

Author: richardbrooks2000

CMakeLists.txt

@@ -96,6 +96,10 @@ add_executable( test_net pctest/test_net.cpp )
 target_link_libraries( test_net ${PC_DEP} )
 add_executable( test_publish pctest/test_publish.cpp )
 target_link_libraries( test_publish ${PC_DEP} )
+add_executable( test_qset pctest/test_qset.cpp )
+target_link_libraries( test_qset ${PC_DEP} )
+add_executable( test_slot pctest/test_slot.cpp )
+target_link_libraries( test_slot ${PC_DEP} )
 
 add_test( test_unit test_unit )
 add_test( test_net test_net )

pc/bincode.hpp

@@ -30,6 +30,7 @@ namespace pc
 
     // sign message at position sig for message starting at position msg
     void sign( size_t sig, size_t msg, const key_pair& );
+    void sign( size_t sig, size_t msg, const key_cache& );
 
     // add values to buffer
     void add( uint8_t );
@@ -193,4 +194,10 @@ namespace pc
     sptr->sign( (const uint8_t*)&buf_[msg], idx_ - msg, kp );
   }
 
+  inline void bincode::sign( size_t sig, size_t msg, const key_cache& kp )
+  {
+    signature *sptr = (signature*)&buf_[sig];
+    sptr->sign( (const uint8_t*)&buf_[msg], idx_ - msg, kp );
+  }
+
 }

pc/key_pair.cpp

@@ -161,6 +161,31 @@ void key_pair::get_pub_key( pub_key& pk ) const
   pk.init_from_buf( &pk_[pub_key::len] );
 }
 
+key_cache::key_cache()
+: ptr_( nullptr )
+{
+}
+
+key_cache::~key_cache()
+{
+  if ( ptr_ ) {
+    EVP_PKEY_free( (EVP_PKEY*)ptr_ );
+    ptr_ = nullptr;
+  }
+}
+
+void key_cache::set( const key_pair& pk )
+{
+  EVP_PKEY *pkey = EVP_PKEY_new_raw_private_key(
+      EVP_PKEY_ED25519, NULL, pk.data(), pub_key::len );
+  ptr_ = (void*)pkey;
+}
+
+void *key_cache::get() const
+{
+  return ptr_;
+}
+
 void signature::init_from_buf( const uint8_t *buf )
 {
   __builtin_memcpy( sig_, buf, len );
@@ -204,6 +229,23 @@ bool signature::sign(
   return rc != 0;
 }
 
+bool signature::sign(
+    const uint8_t* msg, uint32_t msg_len, const key_cache& kp )
+{
+  EVP_PKEY *pkey = (EVP_PKEY*)kp.get();
+  if ( !pkey ) {
+    return false;
+  }
+  EVP_MD_CTX *mctx = EVP_MD_CTX_new();
+  int rc = EVP_DigestSignInit( mctx, NULL, NULL, NULL, pkey );
+  if ( rc ) {
+    size_t sig_len[1] = { len };
+    rc = EVP_DigestSign( mctx, sig_, sig_len, msg, msg_len );
+  }
+  EVP_MD_CTX_free( mctx );
+  return rc != 0;
+}
+
 bool signature::verify(
     const uint8_t* msg, uint32_t msg_len, const pub_key& pk )
 {

pc/key_pair.hpp

@@ -72,6 +72,18 @@ namespace pc
     uint8_t pk_[len];
   };
 
+  // opaque ssl key handle
+  class key_cache
+  {
+  public:
+    key_cache();
+    ~key_cache();
+    void set( const key_pair& );
+    void *get() const;
+  private:
+    void *ptr_;
+  };
+
   // digital signature
   class signature
   {
@@ -90,6 +102,8 @@ namespace pc
     // sign message given key_pair
     bool sign( const uint8_t* msg, uint32_t msg_len,
                const key_pair& );
+    bool sign( const uint8_t* msg, uint32_t msg_len,
+               const key_cache& );
 
     // verify message given public key
     bool verify( const uint8_t* msg, uint32_t msg_len,

pc/key_store.cpp

@@ -41,7 +41,9 @@ key_store::key_store()
   has_mkey_( false ),
   has_mpub_( false ),
   has_gkey_( false ),
-  has_gpub_( false )
+  has_gpub_( false ),
+  has_akey_( false ),
+  has_apub_( false )
 {
 }
 
@@ -126,6 +128,16 @@ std::string key_store::get_program_pub_key_file() const
   return dir_ + "program_key.json";
 }
 
+std::string key_store::get_param_key_pair_file() const
+{
+  return dir_ + "param_key_pair.json";
+}
+
+std::string key_store::get_param_pub_key_file() const
+{
+  return dir_ + "param_key.json";
+}
+
 key_pair *key_store::create_publish_key_pair()
 {
   pkey_.gen();
@@ -146,10 +158,20 @@ key_pair *key_store::get_publish_key_pair()
     return nullptr;
   }
   has_pkey_ = true;
+  ckey_.set( pkey_ );
   pkey_.get_pub_key( ppub_ );
   return &pkey_;
 }
 
+key_cache *key_store::get_publish_key_cache()
+{
+  if ( get_publish_key_pair() ) {
+    return &ckey_;
+  } else {
+    return nullptr;
+  }
+}
+
 pub_key *key_store::get_publish_pub_key()
 {
   if ( has_pkey_ ) {
@@ -243,6 +265,47 @@ pub_key *key_store::get_program_pub_key()
   return &gpub_;
 }
 
+key_pair *key_store::create_param_key_pair()
+{
+  akey_.gen();
+  if ( !write_key_file( get_param_key_pair_file(), akey_ ) ) {
+    return nullptr;
+  }
+  akey_.get_pub_key( apub_ );
+  has_akey_ = true;
+  has_apub_ = true;
+  return &akey_;
+}
+
+key_pair *key_store::get_param_key_pair()
+{
+  if ( has_akey_ ) {
+    return &akey_;
+  }
+  if ( !akey_.init_from_file( get_param_key_pair_file() ) ) {
+    return nullptr;
+  }
+  akey_.get_pub_key( apub_ );
+  has_akey_ = true;
+  has_apub_ = true;
+  return &akey_;
+}
+
+pub_key *key_store::get_param_pub_key()
+{
+  if ( has_apub_ ) {
+    return &apub_;
+  }
+  if ( get_param_key_pair() ) {
+    return &apub_;
+  }
+  if ( !apub_.init_from_file( get_param_pub_key_file() ) ) {
+    return nullptr;
+  }
+  has_apub_ = true;
+  return &apub_;
+}
+
 bool key_store::create_account_key_pair( key_pair& res )
 {
   res.gen();

pc/key_store.hpp

@@ -29,10 +29,13 @@ namespace pc
     std::string get_mapping_pub_key_file() const;
     std::string get_program_key_pair_file() const;
     std::string get_program_pub_key_file() const;
+    std::string get_param_key_pair_file() const;
+    std::string get_param_pub_key_file() const;
 
     // primary publishing and funding key
     key_pair *create_publish_key_pair();
     key_pair *get_publish_key_pair();
+    key_cache*get_publish_key_cache();
     pub_key  *get_publish_pub_key();
 
     // get mapping key_pair or public key
@@ -45,6 +48,11 @@ namespace pc
     key_pair *get_program_key_pair();
     pub_key  *get_program_pub_key();
 
+    // get parameter account key_pair or public key
+    key_pair *create_param_key_pair();
+    key_pair *get_param_key_pair();
+    pub_key  *get_param_pub_key();
+
     // create new mapping or symbol account
     bool create_account_key_pair( key_pair& );
     bool get_account_key_pair( const pub_key&, key_pair& );
@@ -56,12 +64,17 @@ namespace pc
     bool        has_mpub_;
     bool        has_gkey_;
     bool        has_gpub_;
+    bool        has_akey_;
+    bool        has_apub_;
     key_pair    pkey_; // primary publishing and funding key
     key_pair    mkey_; // mapping account key
     key_pair    gkey_; // program key pair
+    key_pair    akey_; // parameter account key pair
+    key_cache   ckey_; // publishing cache key
     pub_key     ppub_; // publisher public key
     pub_key     mpub_; // mapping account public key
     pub_key     gpub_; // program id
+    pub_key     apub_; // parameter account public key
     std::string dir_;  // key store directory
   };
 

pc/manager.cpp

@@ -248,6 +248,10 @@ bool manager::init()
   if ( gpub ) {
     PC_LOG_INF( "program_key" ).add( "key_name", *gpub ).end();
   }
+  pub_key *rkey = get_param_pub_key();
+  if ( rkey ) {
+    PC_LOG_INF( "param_key" ).add( "key_name", *rkey ).end();
+  }
 
   // initialize capture
   if ( do_cap_ && !cap_.init() ) {

pc/manager.hpp

@@ -158,8 +158,8 @@ namespace pc
     bool get_is_tx_connect() const;
 
     // rpc callbacks
-    void on_response( rpc::slot_subscribe * );
-    void on_response( rpc::get_recent_block_hash * );
+    void on_response( rpc::slot_subscribe * ) override;
+    void on_response( rpc::get_recent_block_hash * ) override;
     void set_status( int );
     get_mapping *get_last_mapping() const;