set min pub

Author: jhunsaker

pc/request.cpp

@@ -552,6 +552,11 @@ int64_t price::get_price_exponent() const
   return pptr_->expo_;
 }
 
+uint8_t price::get_min_pub() const
+{
+  return pptr_->min_pub_;
+}
+
 price_type price::get_price_type() const
 {
   return(price_type) pptr_->ptype_;

pc/request.hpp

@@ -275,6 +275,7 @@ namespace pc
     const pub_key *get_account() const;
     price_type     get_price_type() const;
     int64_t        get_price_exponent() const;
+    uint8_t        get_min_pub() const;
     uint32_t       get_version() const;
     int64_t        get_price() const;
     uint64_t       get_conf() const;

pcapps/admin_request.cpp

@@ -744,6 +744,105 @@ bool init_price::get_is_done() const
   return st_ == e_done;
 }
 
+///////////////////////////////////////////////////////////////////////////
+// set_min_pub_req
+
+set_min_pub_req::set_min_pub_req()
+: st_( e_init_sent ),
+  cmt_( commitment::e_confirmed )
+{
+}
+
+void set_min_pub_req::set_min_pub( uint8_t min_pub )
+{
+  req_->set_min_pub( min_pub );
+}
+
+void set_min_pub_req::set_price( price *px )
+{
+  price_ = px;
+}
+
+void set_min_pub_req::set_commitment( commitment cmt )
+{
+  cmt_ = cmt;
+}
+
+bool set_min_pub_req::get_is_ready()
+{
+  manager *cptr = get_manager();
+  if ( !cptr->get_mapping_pub_key() ) {
+    return set_err_msg( "missing mapping key pairfile ["
+        + cptr->get_mapping_key_pair_file() + "]" );
+  }
+  return cptr->has_status( PC_PYTH_RPC_CONNECTED |
+                           PC_PYTH_HAS_BLOCK_HASH |
+                           PC_PYTH_HAS_MAPPING );
+}
+
+void set_min_pub_req::submit()
+{
+  manager *cptr = get_manager();
+  key_pair *pkey = cptr->get_publish_key_pair();
+  if ( !pkey ) {
+    on_error_sub( "missing or invalid publish key [" +
+        cptr->get_publish_key_pair_file() + "]", this );
+    return;
+  }
+  pub_key *gpub = cptr->get_program_pub_key();
+  if ( !gpub ) {
+    on_error_sub( "missing or invalid program public key [" +
+        cptr->get_program_pub_key_file() + "]", this );
+    return;
+  }
+  pub_key *pub = price_->get_account();
+  if ( !cptr->get_account_key_pair( *pub, key_ ) ) {
+    std::string knm;
+    pub->enc_base58( knm );
+    on_error_sub( "missing key pair for price acct [" + knm + "]", this);
+    return;
+  }
+  req_->set_program( gpub );
+  req_->set_publish( pkey );
+  req_->set_account( &key_ );
+  req_->set_sub( this );
+  sig_->set_sub( this );
+
+  // get recent block hash and submit request
+  st_ = e_init_sent;
+  req_->set_block_hash( get_manager()->get_recent_block_hash() );
+  get_rpc_client()->send( req_ );
+}
+
+void set_min_pub_req::on_response( rpc::signature_subscribe *res )
+{
+  if ( res->get_is_err() ) {
+    on_error_sub( res->get_err_msg(), this );
+    st_ = e_error;
+  } else if ( st_ == e_init_sig ) {
+    st_ = e_done;
+    on_response_sub( this );
+  }
+}
+
+void set_min_pub_req::on_response( rpc::set_min_pub_rpc *res )
+{
+  if ( res->get_is_err() ) {
+    on_error_sub( res->get_err_msg(), this );
+    st_ = e_error;
+  } else if ( st_ == e_init_sent ) {
+    st_ = e_init_sig;
+    sig_->set_commitment( cmt_ );
+    sig_->set_signature( res->get_signature() );
+    get_rpc_client()->send( sig_ );
+  }
+}
+
+bool set_min_pub_req::get_is_done() const
+{
+  return st_ == e_done;
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // add_publisher
 

pcapps/admin_request.hpp

@@ -220,6 +220,39 @@ namespace pc
     rpc::signature_subscribe sig_[1];
   };
 
+  // (re)initialize price account to reflect exponent change
+  class set_min_pub_req : public request,
+                          public rpc_sub_i<rpc::signature_subscribe>,
+                          public rpc_sub_i<rpc::set_min_pub_rpc>
+  {
+  public:
+    set_min_pub_req();
+    void set_min_pub( uint8_t );
+    void set_price( price * );
+    void set_commitment( commitment );
+    bool get_is_done() const override;
+
+  public:
+    void on_response( rpc::signature_subscribe * ) override;
+    void on_response( rpc::set_min_pub_rpc * ) override;
+    bool get_is_ready() override;
+    void submit() override;
+
+  private:
+    using request::on_response;
+
+    typedef enum {
+      e_init_sent, e_init_sig, e_done, e_error
+    } state_t;
+
+    state_t                  st_;
+    commitment               cmt_;
+    price                   *price_;
+    key_pair                 key_;
+    rpc::set_min_pub_rpc     req_[1];
+    rpc::signature_subscribe sig_[1];
+  };
+
   // add new price publisher to symbol account
   class add_publisher : public request,
                         public rpc_sub_i<rpc::signature_subscribe>,

pcapps/admin_rpc_client.cpp

@@ -856,6 +856,105 @@ void rpc::init_price::response( const jtree& jt )
   on_response( this );
 }
 
+///////////////////////////////////////////////////////////////////////////
+// set_min_pub_rpc
+
+void rpc::set_min_pub_rpc::set_min_pub( uint8_t min_pub )
+{
+  min_pub_ = min_pub;
+}
+
+void rpc::set_min_pub_rpc::set_program( pub_key *gkey )
+{
+  gkey_ = gkey;
+}
+
+void rpc::set_min_pub_rpc::set_block_hash( hash *bhash )
+{
+  bhash_ = bhash;
+}
+
+void rpc::set_min_pub_rpc::set_publish( key_pair *pkey )
+{
+  pkey_ = pkey;
+}
+
+void rpc::set_min_pub_rpc::set_account( key_pair *akey )
+{
+  akey_ = akey;
+}
+
+signature *rpc::set_min_pub_rpc::get_signature()
+{
+  return &sig_;
+}
+
+rpc::set_min_pub_rpc::set_min_pub_rpc()
+: min_pub_( 0 ),
+  bhash_( nullptr ),
+  pkey_( nullptr ),
+  gkey_( nullptr ),
+  akey_( nullptr )
+{
+}
+
+void rpc::set_min_pub_rpc::request( json_wtr& msg )
+{
+  // construct binary transaction
+  net_buf *bptr = net_buf::alloc();
+  bincode tx( bptr->buf_ );
+
+  // signatures section
+  tx.add_len<2>();      // three signatures (publish, price)
+  size_t pub_idx = tx.reserve_sign();
+  size_t prc_idx = tx.reserve_sign();
+
+  // message header
+  size_t tx_idx = tx.get_pos();
+  tx.add( (uint8_t)2 ); // pub and price signing accounts
+  tx.add( (uint8_t)0 ); // read-only signed accounts
+  tx.add( (uint8_t)1 ); // program-id are read-only unsigned accounts
+
+  // accounts
+  tx.add_len<3>();      // 3 accounts: publish, price, params, program
+  tx.add( *pkey_ );     // publish account
+  tx.add( *akey_ );     // price account
+  tx.add( *gkey_ );     // programid
+
+  // recent block hash
+  tx.add( *bhash_ );    // recent block hash
+
+  // instructions section
+  tx.add_len<1>();      // one instruction
+  tx.add( (uint8_t)2);  // program_id index
+  tx.add_len<2>();      // 2 accounts: publish, price
+  tx.add( (uint8_t)0 ); // index of publish account
+  tx.add( (uint8_t)1 ); // index of price account
+
+  // instruction parameter section
+  tx.add_len<sizeof(cmd_set_min_pub)>();
+  tx.add( (uint32_t)PC_VERSION );
+  tx.add( (int32_t)e_cmd_set_min_pub );
+  tx.add( min_pub_ );
+  tx.add( (uint8_t)0 );
+  tx.add( (uint16_t)0 );
+
+  // all accounts need to sign transaction
+  tx.sign( pub_idx, tx_idx, *pkey_ );
+  sig_.init_from_buf( (const uint8_t*)(tx.get_buf() + pub_idx) );
+  tx.sign( prc_idx, tx_idx, *akey_ );
+
+  // encode transaction and add to json params
+  send_transaction( msg, tx );
+  bptr->dealloc();
+}
+
+void rpc::set_min_pub_rpc::response( const jtree& jt )
+{
+  if ( on_error( jt, this ) ) return;
+  on_response( this );
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // add_publisher
 

pcapps/admin_rpc_client.hpp

@@ -235,6 +235,32 @@ namespace pc {
       signature  sig_;
     };
 
+    // set min publishers on price account
+    class set_min_pub_rpc : public rpc_request
+    {
+    public:
+      void set_min_pub( uint8_t );
+      void set_program( pub_key * );
+      void set_block_hash( hash * );
+      void set_publish( key_pair * );
+      void set_account( key_pair * );
+
+      // results
+      signature *get_signature();
+
+      set_min_pub_rpc();
+      void request( json_wtr& ) override;
+      void response( const jtree& ) override;
+
+    private:
+      uint8_t    min_pub_;
+      hash      *bhash_;
+      key_pair  *pkey_;
+      pub_key   *gkey_;
+      key_pair  *akey_;
+      signature  sig_;
+    };
+
     // add new price publisher to symbol account
     class add_publisher : public rpc_request
     {

pcapps/pyth.cpp

@@ -371,6 +371,8 @@ static void print_product( product *prod )
               << std::endl;
     print_val( "price_exponent", 4 );
     std::cout << ptr->get_price_exponent() << std::endl;
+    print_val( "min_pub", 4 );
+    std::cout << static_cast< unsigned >( ptr->get_min_pub() ) << std::endl;
     print_val( "status", 4 );
     std::cout << symbol_status_to_str( ptr->get_status() ).as_string()
               << std::endl;