flamenco, feature: enable_extend_program_checked

mjain-jump · mjain-jump · commit aa5d3f7eaef0 · 2025-07-23T22:20:28.000Z
diff --git a/src/flamenco/features/fd_features_generated.c b/src/flamenco/features/fd_features_generated.c
@@ -1614,6 +1614,12 @@ fd_feature_id_t const ids[] = {
     .name                      = "formalize_loaded_transaction_data_size",
     .cleaned_up                = {UINT_MAX, UINT_MAX, UINT_MAX} },
 
+  { .index                     = offsetof(fd_features_t, enable_extend_program_checked)>>3,
+    .id                        = {"\x1a\xbb\x7f\x36\x84\xcf\x70\x71\xd5\x7a\xb1\x1e\x63\x2b\xf9\xaf\x28\x4d\x99\x50\x39\x5d\xe9\x70\x11\x8c\x88\x96\xc7\x32\x90\x49"},
+                                 /* 2oMRZEDWT2tqtYMofhmmfQ8SsjqUFzT6sYXppQDavxwz */
+    .name                      = "enable_extend_program_checked",
+    .cleaned_up                = {UINT_MAX, UINT_MAX, UINT_MAX} },
+
   { .index = ULONG_MAX }
 };
 /* TODO replace this with fd_map_perfect */
@@ -1856,6 +1862,7 @@ fd_feature_id_query( ulong prefix ) {
   case 0xec3a4c069e71cb0e: return &ids[ 233 ];
   case 0xbbec21266d76cb0e: return &ids[ 234 ];
   case 0xe72f76507222e3bb: return &ids[ 235 ];
+  case 0x7170cf84367fbb1a: return &ids[ 236 ];
   default: break;
   }
   return NULL;
@@ -2097,4 +2104,5 @@ FD_STATIC_ASSERT( offsetof( fd_features_t, mask_out_rent_epoch_in_vm_serializati
 FD_STATIC_ASSERT( offsetof( fd_features_t, disable_zk_elgamal_proof_program                        )>>3==233UL, layout );
 FD_STATIC_ASSERT( offsetof( fd_features_t, reenable_zk_elgamal_proof_program                       )>>3==234UL, layout );
 FD_STATIC_ASSERT( offsetof( fd_features_t, formalize_loaded_transaction_data_size                  )>>3==235UL, layout );
+FD_STATIC_ASSERT( offsetof( fd_features_t, enable_extend_program_checked                           )>>3==236UL, layout );
 FD_STATIC_ASSERT( sizeof( fd_features_t )>>3==FD_FEATURE_ID_CNT, layout );
diff --git a/src/flamenco/features/fd_features_generated.h b/src/flamenco/features/fd_features_generated.h
@@ -8,7 +8,7 @@
 #endif
 
 /* FEATURE_ID_CNT is the number of features in ids */
-#define FD_FEATURE_ID_CNT (236UL)
+#define FD_FEATURE_ID_CNT (237UL)
 union fd_features {
   ulong f[ FD_FEATURE_ID_CNT ];
   struct {
@@ -248,5 +248,6 @@ union fd_features {
     /* 0xec3a4c069e71cb0e */ ulong disable_zk_elgamal_proof_program;
     /* 0xbbec21266d76cb0e */ ulong reenable_zk_elgamal_proof_program;
     /* 0xe72f76507222e3bb */ ulong formalize_loaded_transaction_data_size;
+    /* 0x7170cf84367fbb1a */ ulong enable_extend_program_checked;
   };
 };
diff --git a/src/flamenco/features/feature_map.json b/src/flamenco/features/feature_map.json
@@ -234,5 +234,6 @@
   {"name":"mask_out_rent_epoch_in_vm_serialization","pubkey":"RENtePQcDLrAbxAsP3k8dwVcnNYQ466hi2uKvALjnXx"},
   {"name":"disable_zk_elgamal_proof_program","pubkey":"zkdoVwnSFnSLtGJG7irJPEYUpmb4i7sGMGcnN6T9rnC"},
   {"name":"reenable_zk_elgamal_proof_program","pubkey":"zkemPXcuM3G4wpMDZ36Cpw34EjUpvm1nuioiSGbGZPR"},
-  {"name":"formalize_loaded_transaction_data_size","pubkey":"DeS7sR48ZcFTUmt5FFEVDr1v1bh73aAbZiZq3SYr8Eh8"}
+  {"name":"formalize_loaded_transaction_data_size","pubkey":"DeS7sR48ZcFTUmt5FFEVDr1v1bh73aAbZiZq3SYr8Eh8"},
+  {"name":"enable_extend_program_checked","pubkey":"2oMRZEDWT2tqtYMofhmmfQ8SsjqUFzT6sYXppQDavxwz"}
 ]
diff --git a/src/flamenco/runtime/program/fd_bpf_loader_program.c b/src/flamenco/runtime/program/fd_bpf_loader_program.c
diff --git a/src/flamenco/types/fd_fuzz_types.h b/src/flamenco/types/fd_fuzz_types.h
@@ -2584,6 +2584,14 @@ void *fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( voi
   return mem;
 }
 
+void *fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *) mem;
+  *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new(mem);
+  self->additional_bytes = fd_rng_uint( rng );
+  return mem;
+}
+
 void fd_bpf_upgradeable_loader_program_instruction_inner_generate( fd_bpf_upgradeable_loader_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
   switch (discriminant) {
   case 1: {
@@ -2598,13 +2606,17 @@ void fd_bpf_upgradeable_loader_program_instruction_inner_generate( fd_bpf_upgrad
     fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( &self->extend_program, alloc_mem, rng );
     break;
   }
+  case 9: {
+    fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( &self->extend_program_checked, alloc_mem, rng );
+    break;
+  }
   }
 }
 void *fd_bpf_upgradeable_loader_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
   fd_bpf_upgradeable_loader_program_instruction_t *self = (fd_bpf_upgradeable_loader_program_instruction_t *) mem;
   *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_t);
   fd_bpf_upgradeable_loader_program_instruction_new(mem);
-  self->discriminant = fd_rng_uint( rng ) % 9;
+  self->discriminant = fd_rng_uint( rng ) % 10;
   fd_bpf_upgradeable_loader_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
   return mem;
 }
diff --git a/src/flamenco/types/fd_types.c b/src/flamenco/types/fd_types.c
@@ -15919,6 +15919,35 @@ void fd_bpf_upgradeable_loader_program_instruction_extend_program_walk( void * w
   fun( w, &self->additional_bytes, "additional_bytes", FD_FLAMENCO_TYPE_UINT, "uint", level, 0  );
   fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_bpf_upgradeable_loader_program_instruction_extend_program", level--, 0 );
 }
+int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_encode( fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_bincode_encode_ctx_t * ctx ) {
+  int err;
+  err = fd_bincode_uint32_encode( self->additional_bytes, ctx );
+  if( FD_UNLIKELY( err ) ) return err;
+  return FD_BINCODE_SUCCESS;
+}
+static inline int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_footprint_inner( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
+  if( (ulong)ctx->data + 4UL > (ulong)ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
+  ctx->data = (void *)( (ulong)ctx->data + 4UL );
+  return 0;
+}
+static void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t * self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *)struct_mem;
+  fd_bincode_uint32_decode_unsafe( &self->additional_bytes, ctx );
+}
+void * fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode( void * mem, fd_bincode_decode_ctx_t * ctx ) {
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t * self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *)mem;
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new( self );
+  void * alloc_region = (uchar *)mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);
+  void * * alloc_mem = &alloc_region;
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( mem, alloc_mem, ctx );
+  return self;
+}
+void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_walk( void * w, fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint ) {
+  (void) varint;
+  fun( w, self, name, FD_FLAMENCO_TYPE_MAP, "fd_bpf_upgradeable_loader_program_instruction_extend_program_checked", level++, 0 );
+  fun( w, &self->additional_bytes, "additional_bytes", FD_FLAMENCO_TYPE_UINT, "uint", level, 0  );
+  fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_bpf_upgradeable_loader_program_instruction_extend_program_checked", level--, 0 );
+}
 FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_initialize_buffer(fd_bpf_upgradeable_loader_program_instruction_t const * self) {
   return self->discriminant == 0;
 }
@@ -15946,6 +15975,9 @@ FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_set_authority_
 FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_migrate(fd_bpf_upgradeable_loader_program_instruction_t const * self) {
   return self->discriminant == 8;
 }
+FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_extend_program_checked(fd_bpf_upgradeable_loader_program_instruction_t const * self) {
+  return self->discriminant == 9;
+}
 void fd_bpf_upgradeable_loader_program_instruction_inner_new( fd_bpf_upgradeable_loader_program_instruction_inner_t * self, uint discriminant );
 int fd_bpf_upgradeable_loader_program_instruction_inner_decode_footprint( uint discriminant, fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
   int err;
@@ -15983,6 +16015,11 @@ int fd_bpf_upgradeable_loader_program_instruction_inner_decode_footprint( uint d
   case 8: {
     return FD_BINCODE_SUCCESS;
   }
+  case 9: {
+    err = fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_footprint_inner( ctx, total_sz );
+    if( FD_UNLIKELY( err ) ) return err;
+    return FD_BINCODE_SUCCESS;
+  }
   default: return FD_BINCODE_ERR_ENCODING;
   }
 }
@@ -16033,6 +16070,10 @@ static void fd_bpf_upgradeable_loader_program_instruction_inner_decode_inner( fd
   case 8: {
     break;
   }
+  case 9: {
+    fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( &self->extend_program_checked, alloc_mem, ctx );
+    break;
+  }
   }
 }
 static void fd_bpf_upgradeable_loader_program_instruction_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {
@@ -16080,6 +16121,10 @@ void fd_bpf_upgradeable_loader_program_instruction_inner_new( fd_bpf_upgradeable
   case 8: {
     break;
   }
+  case 9: {
+    fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new( &self->extend_program_checked );
+    break;
+  }
   default: break; // FD_LOG_ERR(( "unhandled type"));
   }
 }
@@ -16135,6 +16180,11 @@ void fd_bpf_upgradeable_loader_program_instruction_walk( void * w, fd_bpf_upgrad
     fun( w, self, "migrate", FD_FLAMENCO_TYPE_ENUM_DISC, "discriminant", level, 0 );
     break;
   }
+  case 9: {
+    fun( w, self, "extend_program_checked", FD_FLAMENCO_TYPE_ENUM_DISC, "discriminant", level, 0 );
+    fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_walk( w, &self->inner.extend_program_checked, fun, "extend_program_checked", level, 0 );
+    break;
+  }
   }
   fun( w, self, name, FD_FLAMENCO_TYPE_ENUM_END, "fd_bpf_upgradeable_loader_program_instruction", level--, 0 );
 }
@@ -16154,6 +16204,10 @@ ulong fd_bpf_upgradeable_loader_program_instruction_size( fd_bpf_upgradeable_loa
     size += fd_bpf_upgradeable_loader_program_instruction_extend_program_size( &self->inner.extend_program );
     break;
   }
+  case 9: {
+    size += fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_size( &self->inner.extend_program_checked );
+    break;
+  }
   }
   return size;
 }
@@ -16176,6 +16230,11 @@ int fd_bpf_upgradeable_loader_program_instruction_inner_encode( fd_bpf_upgradeab
     if( FD_UNLIKELY( err ) ) return err;
     break;
   }
+  case 9: {
+    err = fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_encode( &self->extend_program_checked, ctx );
+    if( FD_UNLIKELY( err ) ) return err;
+    break;
+  }
   }
   return FD_BINCODE_SUCCESS;
 }
diff --git a/src/flamenco/types/fd_types.h b/src/flamenco/types/fd_types.h
@@ -2572,10 +2572,18 @@ struct fd_bpf_upgradeable_loader_program_instruction_extend_program {
 typedef struct fd_bpf_upgradeable_loader_program_instruction_extend_program fd_bpf_upgradeable_loader_program_instruction_extend_program_t;
 #define FD_BPF_UPGRADEABLE_LOADER_PROGRAM_INSTRUCTION_EXTEND_PROGRAM_ALIGN alignof(fd_bpf_upgradeable_loader_program_instruction_extend_program_t)
 
+/* Encoded Size: Fixed (4 bytes) */
+struct fd_bpf_upgradeable_loader_program_instruction_extend_program_checked {
+  uint additional_bytes;
+};
+typedef struct fd_bpf_upgradeable_loader_program_instruction_extend_program_checked fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t;
+#define FD_BPF_UPGRADEABLE_LOADER_PROGRAM_INSTRUCTION_EXTEND_PROGRAM_CHECKED_ALIGN alignof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t)
+
 union fd_bpf_upgradeable_loader_program_instruction_inner {
   fd_bpf_upgradeable_loader_program_instruction_write_t write;
   fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_t deploy_with_max_data_len;
   fd_bpf_upgradeable_loader_program_instruction_extend_program_t extend_program;
+  fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t extend_program_checked;
 };
 typedef union fd_bpf_upgradeable_loader_program_instruction_inner fd_bpf_upgradeable_loader_program_instruction_inner_t;
 
@@ -5402,6 +5410,18 @@ static inline int fd_bpf_upgradeable_loader_program_instruction_extend_program_d
 }
 void * fd_bpf_upgradeable_loader_program_instruction_extend_program_decode( void * mem, fd_bincode_decode_ctx_t * ctx );
 
+static inline void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new( fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t * self ) { fd_memset( self, 0, sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t) ); }
+int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_encode( fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_bincode_encode_ctx_t * ctx );
+void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_walk( void * w, fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint );
+static inline ulong fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_size( fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self ) { (void)self; return 4UL; }
+static inline ulong fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_align( void ) { return FD_BPF_UPGRADEABLE_LOADER_PROGRAM_INSTRUCTION_EXTEND_PROGRAM_CHECKED_ALIGN; }
+static inline int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_footprint( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {
+  *total_sz += sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);
+  if( (ulong)ctx->data + 4UL > (ulong)ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };
+  return 0;
+}
+void * fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode( void * mem, fd_bincode_decode_ctx_t * ctx );
+
 void fd_bpf_upgradeable_loader_program_instruction_new_disc( fd_bpf_upgradeable_loader_program_instruction_t * self, uint discriminant );
 void fd_bpf_upgradeable_loader_program_instruction_new( fd_bpf_upgradeable_loader_program_instruction_t * self );
 int fd_bpf_upgradeable_loader_program_instruction_encode( fd_bpf_upgradeable_loader_program_instruction_t const * self, fd_bincode_encode_ctx_t * ctx );
@@ -5420,6 +5440,7 @@ FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_close( fd_bpf_
 FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_extend_program( fd_bpf_upgradeable_loader_program_instruction_t const * self );
 FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_set_authority_checked( fd_bpf_upgradeable_loader_program_instruction_t const * self );
 FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_migrate( fd_bpf_upgradeable_loader_program_instruction_t const * self );
+FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_extend_program_checked( fd_bpf_upgradeable_loader_program_instruction_t const * self );
 enum {
 fd_bpf_upgradeable_loader_program_instruction_enum_initialize_buffer = 0,
 fd_bpf_upgradeable_loader_program_instruction_enum_write = 1,
@@ -5430,6 +5451,7 @@ fd_bpf_upgradeable_loader_program_instruction_enum_close = 5,
 fd_bpf_upgradeable_loader_program_instruction_enum_extend_program = 6,
 fd_bpf_upgradeable_loader_program_instruction_enum_set_authority_checked = 7,
 fd_bpf_upgradeable_loader_program_instruction_enum_migrate = 8,
+fd_bpf_upgradeable_loader_program_instruction_enum_extend_program_checked = 9,
 };
 void fd_bpf_upgradeable_loader_state_buffer_new( fd_bpf_upgradeable_loader_state_buffer_t * self );
 int fd_bpf_upgradeable_loader_state_buffer_encode( fd_bpf_upgradeable_loader_state_buffer_t const * self, fd_bincode_encode_ctx_t * ctx );
diff --git a/src/flamenco/types/fd_types.json b/src/flamenco/types/fd_types.json
@@ -1665,6 +1665,13 @@
         { "name": "additional_bytes", "type": "uint" }
       ]
     },
+    {
+      "name": "bpf_upgradeable_loader_program_instruction_extend_program_checked",
+      "type": "struct",
+      "fields": [
+        { "name": "additional_bytes", "type": "uint" }
+      ]
+    },
     {
       "name": "bpf_upgradeable_loader_program_instruction",
       "type": "enum",
@@ -1677,7 +1684,8 @@
         { "name": "close" },
         { "name": "extend_program", "type": "bpf_upgradeable_loader_program_instruction_extend_program" },
         { "name": "set_authority_checked" },
-        { "name": "migrate" }
+        { "name": "migrate" },
+        { "name": "extend_program_checked", "type": "bpf_upgradeable_loader_program_instruction_extend_program_checked" }
       ]
     },
     {
diff --git a/src/flamenco/types/fd_types_reflect_generated.c b/src/flamenco/types/fd_types_reflect_generated.c
diff --git a/src/flamenco/vm/syscall/fd_vm_syscall_cpi.c b/src/flamenco/vm/syscall/fd_vm_syscall_cpi.c

Original file line number	Diff line number	Diff line change
`@@ -234,5 +234,6 @@`
`234`	`234`	`{"name":"mask_out_rent_epoch_in_vm_serialization","pubkey":"RENtePQcDLrAbxAsP3k8dwVcnNYQ466hi2uKvALjnXx"},`
`235`	`235`	`{"name":"disable_zk_elgamal_proof_program","pubkey":"zkdoVwnSFnSLtGJG7irJPEYUpmb4i7sGMGcnN6T9rnC"},`
`236`	`236`	`{"name":"reenable_zk_elgamal_proof_program","pubkey":"zkemPXcuM3G4wpMDZ36Cpw34EjUpvm1nuioiSGbGZPR"},`
`237`		`- {"name":"formalize_loaded_transaction_data_size","pubkey":"DeS7sR48ZcFTUmt5FFEVDr1v1bh73aAbZiZq3SYr8Eh8"}`
	`237`	`+ {"name":"formalize_loaded_transaction_data_size","pubkey":"DeS7sR48ZcFTUmt5FFEVDr1v1bh73aAbZiZq3SYr8Eh8"},`
	`238`	`+ {"name":"enable_extend_program_checked","pubkey":"2oMRZEDWT2tqtYMofhmmfQ8SsjqUFzT6sYXppQDavxwz"}`
`238`	`239`	`]`
Original file line number	Diff line number	Diff line change
`@@ -15919,6 +15919,35 @@ void fd_bpf_upgradeable_loader_program_instruction_extend_program_walk( void * w`
`15919`	`15919`	`fun( w, &self->additional_bytes, "additional_bytes", FD_FLAMENCO_TYPE_UINT, "uint", level, 0 );`
`15920`	`15920`	`fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_bpf_upgradeable_loader_program_instruction_extend_program", level--, 0 );`
`15921`	`15921`	`}`
	`15922`	`+int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_encode( fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_bincode_encode_ctx_t * ctx ) {`
	`15923`	`+ int err;`
	`15924`	`+ err = fd_bincode_uint32_encode( self->additional_bytes, ctx );`
	`15925`	`+ if( FD_UNLIKELY( err ) ) return err;`
	`15926`	`+ return FD_BINCODE_SUCCESS;`
	`15927`	`+}`
	`15928`	`+static inline int fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_footprint_inner( fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {`
	`15929`	`+ if( (ulong)ctx->data + 4UL > (ulong)ctx->dataend ) { return FD_BINCODE_ERR_OVERFLOW; };`
	`15930`	`+ ctx->data = (void *)( (ulong)ctx->data + 4UL );`
	`15931`	`+ return 0;`
	`15932`	`+}`
	`15933`	`+static void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {`
	`15934`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t * self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *)struct_mem;`
	`15935`	`+ fd_bincode_uint32_decode_unsafe( &self->additional_bytes, ctx );`
	`15936`	`+}`
	`15937`	`+void * fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode( void * mem, fd_bincode_decode_ctx_t * ctx ) {`
	`15938`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t * self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *)mem;`
	`15939`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new( self );`
	`15940`	`+ void * alloc_region = (uchar *)mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);`
	`15941`	`+ void * * alloc_mem = &alloc_region;`
	`15942`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( mem, alloc_mem, ctx );`
	`15943`	`+ return self;`
	`15944`	`+}`
	`15945`	`+void fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_walk( void * w, fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t const * self, fd_types_walk_fn_t fun, const char *name, uint level, uint varint ) {`
	`15946`	`+ (void) varint;`
	`15947`	`+ fun( w, self, name, FD_FLAMENCO_TYPE_MAP, "fd_bpf_upgradeable_loader_program_instruction_extend_program_checked", level++, 0 );`
	`15948`	`+ fun( w, &self->additional_bytes, "additional_bytes", FD_FLAMENCO_TYPE_UINT, "uint", level, 0 );`
	`15949`	`+ fun( w, self, name, FD_FLAMENCO_TYPE_MAP_END, "fd_bpf_upgradeable_loader_program_instruction_extend_program_checked", level--, 0 );`
	`15950`	`+}`
`15922`	`15951`	`FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_initialize_buffer(fd_bpf_upgradeable_loader_program_instruction_t const * self) {`
`15923`	`15952`	`return self->discriminant == 0;`
`15924`	`15953`	`}`
`@@ -15946,6 +15975,9 @@ FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_set_authority_`
`15946`	`15975`	`FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_migrate(fd_bpf_upgradeable_loader_program_instruction_t const * self) {`
`15947`	`15976`	`return self->discriminant == 8;`
`15948`	`15977`	`}`
	`15978`	`+FD_FN_PURE uchar fd_bpf_upgradeable_loader_program_instruction_is_extend_program_checked(fd_bpf_upgradeable_loader_program_instruction_t const * self) {`
	`15979`	`+ return self->discriminant == 9;`
	`15980`	`+}`
`15949`	`15981`	`void fd_bpf_upgradeable_loader_program_instruction_inner_new( fd_bpf_upgradeable_loader_program_instruction_inner_t * self, uint discriminant );`
`15950`	`15982`	`int fd_bpf_upgradeable_loader_program_instruction_inner_decode_footprint( uint discriminant, fd_bincode_decode_ctx_t * ctx, ulong * total_sz ) {`
`15951`	`15983`	`int err;`
`@@ -15983,6 +16015,11 @@ int fd_bpf_upgradeable_loader_program_instruction_inner_decode_footprint( uint d`
`15983`	`16015`	`case 8: {`
`15984`	`16016`	`return FD_BINCODE_SUCCESS;`
`15985`	`16017`	`}`
	`16018`	`+ case 9: {`
	`16019`	`+ err = fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_footprint_inner( ctx, total_sz );`
	`16020`	`+ if( FD_UNLIKELY( err ) ) return err;`
	`16021`	`+ return FD_BINCODE_SUCCESS;`
	`16022`	`+ }`
`15986`	`16023`	`default: return FD_BINCODE_ERR_ENCODING;`
`15987`	`16024`	`}`
`15988`	`16025`	`}`
`@@ -16033,6 +16070,10 @@ static void fd_bpf_upgradeable_loader_program_instruction_inner_decode_inner( fd`
`16033`	`16070`	`case 8: {`
`16034`	`16071`	`break;`
`16035`	`16072`	`}`
	`16073`	`+ case 9: {`
	`16074`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_decode_inner( &self->extend_program_checked, alloc_mem, ctx );`
	`16075`	`+ break;`
	`16076`	`+ }`
`16036`	`16077`	`}`
`16037`	`16078`	`}`
`16038`	`16079`	`static void fd_bpf_upgradeable_loader_program_instruction_decode_inner( void * struct_mem, void * * alloc_mem, fd_bincode_decode_ctx_t * ctx ) {`
`@@ -16080,6 +16121,10 @@ void fd_bpf_upgradeable_loader_program_instruction_inner_new( fd_bpf_upgradeable`
`16080`	`16121`	`case 8: {`
`16081`	`16122`	`break;`
`16082`	`16123`	`}`
	`16124`	`+ case 9: {`
	`16125`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new( &self->extend_program_checked );`
	`16126`	`+ break;`
	`16127`	`+ }`
`16083`	`16128`	`default: break; // FD_LOG_ERR(( "unhandled type"));`
`16084`	`16129`	`}`
`16085`	`16130`	`}`
`@@ -16135,6 +16180,11 @@ void fd_bpf_upgradeable_loader_program_instruction_walk( void * w, fd_bpf_upgrad`
`16135`	`16180`	`fun( w, self, "migrate", FD_FLAMENCO_TYPE_ENUM_DISC, "discriminant", level, 0 );`
`16136`	`16181`	`break;`
`16137`	`16182`	`}`
	`16183`	`+ case 9: {`
	`16184`	`+ fun( w, self, "extend_program_checked", FD_FLAMENCO_TYPE_ENUM_DISC, "discriminant", level, 0 );`
	`16185`	`+ fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_walk( w, &self->inner.extend_program_checked, fun, "extend_program_checked", level, 0 );`
	`16186`	`+ break;`
	`16187`	`+ }`
`16138`	`16188`	`}`
`16139`	`16189`	`fun( w, self, name, FD_FLAMENCO_TYPE_ENUM_END, "fd_bpf_upgradeable_loader_program_instruction", level--, 0 );`
`16140`	`16190`	`}`
`@@ -16154,6 +16204,10 @@ ulong fd_bpf_upgradeable_loader_program_instruction_size( fd_bpf_upgradeable_loa`
`16154`	`16204`	`size += fd_bpf_upgradeable_loader_program_instruction_extend_program_size( &self->inner.extend_program );`
`16155`	`16205`	`break;`
`16156`	`16206`	`}`
	`16207`	`+ case 9: {`
	`16208`	`+ size += fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_size( &self->inner.extend_program_checked );`
	`16209`	`+ break;`
	`16210`	`+ }`
`16157`	`16211`	`}`
`16158`	`16212`	`return size;`
`16159`	`16213`	`}`
`@@ -16176,6 +16230,11 @@ int fd_bpf_upgradeable_loader_program_instruction_inner_encode( fd_bpf_upgradeab`
`16176`	`16230`	`if( FD_UNLIKELY( err ) ) return err;`
`16177`	`16231`	`break;`
`16178`	`16232`	`}`
	`16233`	`+ case 9: {`
	`16234`	`+ err = fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_encode( &self->extend_program_checked, ctx );`
	`16235`	`+ if( FD_UNLIKELY( err ) ) return err;`
	`16236`	`+ break;`
	`16237`	`+ }`
`16179`	`16238`	`}`
`16180`	`16239`	`return FD_BINCODE_SUCCESS;`
`16181`	`16240`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1665,6 +1665,13 @@`
`1665`	`1665`	`{ "name": "additional_bytes", "type": "uint" }`
`1666`	`1666`	`]`
`1667`	`1667`	`},`
	`1668`	`+ {`
	`1669`	`+ "name": "bpf_upgradeable_loader_program_instruction_extend_program_checked",`
	`1670`	`+ "type": "struct",`
	`1671`	`+ "fields": [`
	`1672`	`+ { "name": "additional_bytes", "type": "uint" }`
	`1673`	`+ ]`
	`1674`	`+ },`
`1668`	`1675`	`{`
`1669`	`1676`	`"name": "bpf_upgradeable_loader_program_instruction",`
`1670`	`1677`	`"type": "enum",`
`@@ -1677,7 +1684,8 @@`
`1677`	`1684`	`{ "name": "close" },`
`1678`	`1685`	`{ "name": "extend_program", "type": "bpf_upgradeable_loader_program_instruction_extend_program" },`
`1679`	`1686`	`{ "name": "set_authority_checked" },`
`1680`		`- { "name": "migrate" }`
	`1687`	`+ { "name": "migrate" },`
	`1688`	`+ { "name": "extend_program_checked", "type": "bpf_upgradeable_loader_program_instruction_extend_program_checked" }`
`1681`	`1689`	`]`
`1682`	`1690`	`},`
`1683`	`1691`	`{`