Add e_cmd_batch_upd_price

Author: tompntn

program/src/oracle/oracle.c

@@ -507,7 +507,7 @@ static bool is_valid_price_upd( cmd_upd_price_t *cptr, SolAccountInfo *price_acc
 
   // Reject if this price corresponds to the same or earlier time
   pc_price_info_t *fptr = &pptr->comp_[comp_idx].latest_;
-  if ( cptr->cmd_ == e_cmd_upd_price &&
+  if ( ( cptr->cmd_ == e_cmd_upd_price || cptr->cmd_ == e_cmd_batch_upd_price ) &&
        cptr->pub_slot_ <= fptr->pub_slot_ ) {
     return false;
   }
@@ -525,14 +525,72 @@ static void do_price_upd( cmd_upd_price_t *cptr, SolAccountInfo *clock_account,
 
   // update component price if required
   pc_price_info_t *fptr = &pptr->comp_[comp_idx].latest_;
-  if ( cptr->cmd_ == e_cmd_upd_price ) {
+  if ( ( cptr->cmd_ == e_cmd_upd_price || cptr->cmd_ == e_cmd_batch_upd_price ) ) {
     fptr->price_    = cptr->price_;
     fptr->conf_     = cptr->conf_;
     fptr->status_   = cptr->status_;
     fptr->pub_slot_ = cptr->pub_slot_;
   }
 }
 
+static uint64_t batch_upd_price( SolParameters *prm, SolAccountInfo *ka ) {
+  // Check that header information has been provided
+  if ( prm->data_len < sizeof( cmd_batch_upd_price_header_t ) ) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+  cmd_batch_upd_price_header_t *hptr = (cmd_batch_upd_price_header_t *)prm->data;
+
+  // Check that within the batch, the correct number of updates have been provided
+  if ( prm->data_len != ( sizeof( cmd_batch_upd_price_header_t ) + ( hptr->count_ * sizeof( cmd_upd_price_t ) ) ) ) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+  cmd_batch_upd_price_t *cptr = (cmd_batch_upd_price_t *)prm->data;
+
+  // Check that the correct number of account keys have been provided.
+  // We expect the publisher account, the clock account and the price accounts to be present.
+  if ( prm->ka_num != ( 2 + hptr->count_ ) ) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+  SolAccountInfo *publish_account = &ka[0];
+  SolAccountInfo *clock_account = &ka[hptr->count_ + 1];
+
+  // Check that the publish accounts and the clock accounts are valid
+  if ( !valid_funding_account( publish_account ) ||
+       !pc_pub_key_equal( (pc_pub_key_t*)clock_account->key, (pc_pub_key_t*)sysvar_clock ) ) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+
+  // Loop over all the given updates.
+  bool any_succeeded = false;
+  for ( uint64_t i = 0; i < hptr->count_; i++ ) {
+
+    cmd_upd_price_t *uptr = &cptr->upds_[i];
+    SolAccountInfo *price_account = &ka[1 + i];
+
+    // Check that the price account is signed, writable with the correct ownership and is of the correct size
+    if ( !valid_writable_account( prm, price_account, sizeof( pc_price_t ) ) ) {
+      continue;
+    }
+
+    // Check that this price update is valid
+    uint32_t comp_idx = find_comp_idx( publish_account, price_account );
+    if ( !is_valid_price_upd( uptr, price_account, comp_idx ) ) {
+      continue;
+    }
+
+    do_price_upd( uptr, clock_account, price_account, comp_idx );
+
+    any_succeeded = true;
+  }
+
+  // Fail the transaction if no updates succeeded
+  if ( !any_succeeded && hptr->count_ > 0 ) {
+    return ERROR_INVALID_ARGUMENT;
+  }
+
+  return SUCCESS;
+}
+
 static uint64_t upd_price( SolParameters *prm, SolAccountInfo *ka )
 {
   // Validate command parameters
@@ -581,25 +639,30 @@ static uint64_t dispatch( SolParameters *prm, SolAccountInfo *ka )
   }
   switch(hdr->cmd_) {
     case e_cmd_upd_price:
-    case e_cmd_agg_price:     return upd_price( prm, ka );
-    case e_cmd_init_mapping:  return init_mapping( prm, ka );
-    case e_cmd_add_mapping:   return add_mapping( prm, ka );
-    case e_cmd_add_product:   return add_product( prm, ka );
-    case e_cmd_upd_product:   return upd_product( prm, ka );
-    case e_cmd_add_price:     return add_price( prm, ka );
-    case e_cmd_add_publisher: return add_publisher( prm, ka );
-    case e_cmd_del_publisher: return del_publisher( prm, ka );
-    case e_cmd_init_price:    return init_price( prm, ka );
-    case e_cmd_init_test:     return init_test( prm, ka );
-    case e_cmd_upd_test:      return upd_test( prm, ka );
-    case e_cmd_set_min_pub:   return set_min_pub( prm, ka );
-    default:                  return ERROR_INVALID_ARGUMENT;
+    case e_cmd_agg_price:       return upd_price( prm, ka );
+    case e_cmd_batch_upd_price: return batch_upd_price( prm, ka );
+    case e_cmd_init_mapping:    return init_mapping( prm, ka );
+    case e_cmd_add_mapping:     return add_mapping( prm, ka );
+    case e_cmd_add_product:     return add_product( prm, ka );
+    case e_cmd_upd_product:     return upd_product( prm, ka );
+    case e_cmd_add_price:       return add_price( prm, ka );
+    case e_cmd_add_publisher:   return add_publisher( prm, ka );
+    case e_cmd_del_publisher:   return del_publisher( prm, ka );
+    case e_cmd_init_price:      return init_price( prm, ka );
+    case e_cmd_init_test:       return init_test( prm, ka );
+    case e_cmd_upd_test:        return upd_test( prm, ka );
+    case e_cmd_set_min_pub:     return set_min_pub( prm, ka );
+    default:                    return ERROR_INVALID_ARGUMENT;
   }
 }
 
 extern uint64_t entrypoint(const uint8_t *input)
 {
-  SolAccountInfo ka[4];
+  // Batch transactions contain a price account for each symbol,
+  // the publishing account and the sysvar_clock account.
+  int16_t num_accounts = MAX_BATCH_UPD_PRICE_COUNT + 2;
+  SolAccountInfo ka[num_accounts];
+
   SolParameters prm[1];
   prm->ka = ka;
   if (!sol_deserialize(input, prm, SOL_ARRAY_SIZE(ka))) {

program/src/oracle/oracle.h

@@ -221,6 +221,12 @@ typedef enum {
   // key[2] sysvar_clock account  [readable]
   e_cmd_upd_price,
 
+  // publish a batch of component prices
+  // key[0]    funding account       [signer writable]
+  // key[1..n] price accounts        [writable]
+  // key[n]    sysvar_clock account  [readable]
+  e_cmd_batch_upd_price,
+
   // compute aggregate price
   // key[0] funding account       [signer writable]
   // key[1] price account         [writable]
@@ -334,6 +340,26 @@ typedef struct cmd_upd_price
 
 static_assert( sizeof( cmd_upd_price_t ) == 40, "" );
 
+// The maximum amount of price updates that pythd will send.
+// The limiting factor is the maximum size of a pythd JRPC request, 
+// so we may be able to increase this in the futute.
+#define MAX_BATCH_UPD_PRICE_COUNT 8
+
+typedef struct cmd_batch_upd_price_header
+{
+  uint32_t ver_;
+  int32_t cmd_;
+  uint64_t count_; 
+} cmd_batch_upd_price_header_t;
+
+static_assert( sizeof( cmd_batch_upd_price_header_t ) == 16, "" );
+
+typedef struct cmd_batch_upd_price
+{
+  cmd_batch_upd_price_header_t header_;
+  cmd_upd_price_t upds_[0];
+} cmd_batch_upd_price_t;
+
 typedef struct cmd_upd_test
 {
   uint32_t     ver_;

program/src/oracle/test_oracle.c

@@ -448,6 +448,127 @@ Test( oracle, upd_price ) {
   cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
 }
 
+Test( oracle, batch_upd_price ) {
+
+  // In this test we submit a batch update containing both a valid and invalid
+  // price update. The valid update should have affect, the invalid update
+  // should not, and the transaction should complete successfully.
+
+  // Set up the Solana accounts
+  SolPubkey p_id  = {.x = { 0xff, }};
+  SolPubkey pkey = {.x = { 1, }};
+  SolPubkey skey = {.x = { 3, }};
+  sysvar_clock_t cvar = {
+    .slot_ = 1
+  };
+  uint64_t pqty = 100, sqty = 200;
+
+  uint64_t num_price_accounts = 2;
+  pc_price_t sptr[num_price_accounts];
+  for ( uint64_t i = 0; i < num_price_accounts; i++) {
+    sol_memset( &sptr[i], 0, sizeof( pc_price_t ) );
+    sptr[i].magic_ = PC_MAGIC;
+    sptr[i].ver_   = PC_VERSION;
+    sptr[i].ptype_ = PC_PTYPE_PRICE;
+    sptr[i].type_  = PC_ACCTYPE_PRICE;
+    sptr[i].num_   = 1;
+    pc_pub_key_assign( &sptr[i].comp_[0].pub_, (pc_pub_key_t*)&pkey );
+  }
+
+  SolAccountInfo acc[] = {{
+      .key         = &pkey,
+      .lamports    = &pqty,
+      .data_len    = 0,
+      .data        = NULL,
+      .owner       = NULL,
+      .rent_epoch  = 0,
+      .is_signer   = true,
+      .is_writable = true,
+      .executable  = false
+  },{
+      .key         = &skey,
+      .lamports    = &sqty,
+      .data_len    = sizeof( pc_price_t ),
+      .data        = (uint8_t*)&sptr[0],
+      .owner       = &p_id,
+      .rent_epoch  = 0,
+      .is_signer   = false,
+      .is_writable = true,
+      .executable  = false
+  },{
+      .key         = &skey,
+      .lamports    = &sqty,
+      .data_len    = sizeof( pc_price_t ),
+      .data        = (uint8_t*)&sptr[1],
+      .owner       = &p_id,
+      .rent_epoch  = 0,
+      .is_signer   = false,
+      .is_writable = true,
+      .executable  = false
+  },{
+      .key         = (SolPubkey*)sysvar_clock,
+      .lamports    = &sqty,
+      .data_len    = sizeof( sysvar_clock_t ),
+      .data        = (uint8_t*)&cvar,
+      .owner       = &p_id,
+      .rent_epoch  = 0,
+      .is_signer   = false,
+      .is_writable = false,
+      .executable  = false
+  }};
+
+  // Create a request with two updates: one valid and one invalid
+  uint64_t data_len = sizeof(cmd_batch_upd_price_header_t) + (sizeof(cmd_upd_price_t) * num_price_accounts);
+  char input_data[data_len]; 
+  cmd_batch_upd_price_t *req = (cmd_batch_upd_price_t*)&input_data;
+  req->header_.ver_ = PC_VERSION;
+  req->header_.cmd_ = e_cmd_batch_upd_price;
+  req->header_.count_ = 2;
+
+  // The valid update
+  cmd_upd_price_t *upd = &req->upds_[0];
+  upd->ver_ = PC_VERSION;
+  upd->cmd_ = e_cmd_batch_upd_price;
+  upd->status_ = PC_STATUS_TRADING;
+  upd->price_ = 55L;
+  upd->conf_ = 9L;
+  upd->pub_slot_ = 1;
+
+  // The invalid update: incorrect program version
+  upd = &req->upds_[1];
+  upd->ver_ = 1;
+  upd->cmd_ = e_cmd_batch_upd_price;
+  upd->status_ = PC_STATUS_TRADING;
+  upd->price_ = 73L;
+  upd->conf_ = 8L;
+  upd->pub_slot_ = 1;
+
+  SolParameters prm = {
+    .ka         = acc,
+    .ka_num     = 4,
+    .data       = (const uint8_t*)req,
+    .data_len   = data_len,
+    .program_id = &p_id
+  };
+
+  // Dispatch the request and check that the transaction completed successfully
+  cr_assert( SUCCESS == dispatch( &prm, acc ) );
+
+  // Check that the first account got updated successfully
+  cr_assert( sptr[0].comp_[0].latest_.price_ == 55L );
+  cr_assert( sptr[0].comp_[0].latest_.conf_ == 9L );
+  cr_assert( sptr[0].comp_[0].latest_.pub_slot_ == 1 );
+  cr_assert( sptr[0].agg_.pub_slot_ == 1 );
+  cr_assert( sptr[0].valid_slot_ == 0 );
+
+  // Check that the second account didn't
+  cr_assert( sptr[1].comp_[0].latest_.price_ == 0L );
+  cr_assert( sptr[1].comp_[0].latest_.conf_ == 0L );
+  cr_assert( sptr[1].comp_[0].latest_.pub_slot_ == 0 );
+  cr_assert( sptr[1].agg_.pub_slot_ == 0 );
+  cr_assert( sptr[1].valid_slot_ == 0 );
+}
+
 Test( oracle, upd_aggregate ) {
   pc_price_t px[1];
   sol_memset( px, 0, sizeof( pc_price_t ) );