Pointer for programs

CHANGELOG.md

@@ -11,6 +11,13 @@ At the moment this project **does not** adhere to
 
 -  Test CLI which calls the same code as in integration tests ([#417](https://github.com/entropyxyz/entropy-core/pull/417))
 
+### Breaking Changes
+
+- In [#536](https://github.com/entropyxyz/entropy-core/pull/536/), the registered struct no longer holds a program but rather a hash of a program that is set in the set_program function 
+
+### Added
+- Pointer for Programs ([#536](https://github.com/entropyxyz/entropy-core/pull/536/))
+
 ## [0.0.9](https://github.com/entropyxyz/entropy-core/compare/release/v0.0.8..release/v0.0.9) - 2023-11-30
 
 Some of the noteworthy changes related to this release are related to better integration in Web

crypto/server/src/helpers/substrate.rs

@@ -1,13 +1,18 @@
-use entropy_shared::{KeyVisibility, SIGNING_PARTY_SIZE};
-use subxt::{
-    backend::legacy::LegacyRpcMethods, ext::sp_core::sr25519, tx::PairSigner, utils::AccountId32,
-    Config, OnlineClient,
-};
-
 use crate::{
-    chain_api::{entropy, EntropyConfig},
+    chain_api::{
+        entropy::{self, runtime_types::pallet_relayer::pallet::RegisteredInfo},
+        EntropyConfig,
+    },
     user::UserErr,
 };
+use entropy_shared::SIGNING_PARTY_SIZE;
+use subxt::{
+    backend::legacy::LegacyRpcMethods,
+    ext::sp_core::sr25519,
+    tx::PairSigner,
+    utils::{AccountId32, H256},
+    Config, OnlineClient,
+};
 
 /// gets the subgroup of the working validator
 pub async fn get_subgroup(
@@ -71,72 +76,29 @@ pub async fn return_all_addresses_of_subgroup(
 pub async fn get_program(
     substrate_api: &OnlineClient<EntropyConfig>,
     rpc: &LegacyRpcMethods<EntropyConfig>,
-    sig_req_account: &<EntropyConfig as Config>::AccountId,
+    program_pointer: &<EntropyConfig as Config>::Hash,
 ) -> Result<Vec<u8>, UserErr> {
-    let bytecode_address = entropy::storage().programs().bytecode(sig_req_account);
     let block_hash = rpc
         .chain_get_block_hash(None)
         .await?
         .ok_or_else(|| UserErr::OptionUnwrapError("Error getting block hash".to_string()))?;
+    let bytecode_address = entropy::storage().programs().programs(program_pointer);
 
-    substrate_api
+    Ok(substrate_api
         .storage()
         .at(block_hash)
         .fetch(&bytecode_address)
         .await?
-        .ok_or(UserErr::NoProgramDefined)
-}
-
-/// Puts a user in the Registering state on-chain and waits for that transaction to be included in a
-/// block
-#[cfg(test)]
-pub async fn make_register(
-    api: &OnlineClient<EntropyConfig>,
-    rpc: &LegacyRpcMethods<EntropyConfig>,
-    sig_req_keyring: sr25519::Pair,
-    program_modification_account: &AccountId32,
-    key_visibility: KeyVisibility,
-) {
-    use subxt::utils::Static;
-
-    let sig_req_account = PairSigner::<EntropyConfig, sr25519::Pair>::new(sig_req_keyring);
-
-    let registering_query = entropy::storage().relayer().registering(sig_req_account.account_id());
-    let block_hash = rpc.chain_get_block_hash(None).await.unwrap().unwrap();
-    let is_registering_1 = api.storage().at(block_hash).fetch(&registering_query).await.unwrap();
-    assert!(is_registering_1.is_none());
-
-    // register the user
-    let empty_program = vec![];
-    let registering_tx = entropy::tx().relayer().register(
-        program_modification_account.clone(),
-        Static(key_visibility),
-        empty_program,
-    );
-
-    api.tx()
-        .sign_and_submit_then_watch_default(&registering_tx, &sig_req_account)
-        .await
-        .unwrap()
-        .wait_for_in_block()
-        .await
-        .unwrap()
-        .wait_for_success()
-        .await
-        .unwrap();
-
-    let block_hash_2 = rpc.chain_get_block_hash(None).await.unwrap().unwrap();
-
-    let query_registering_status = api.storage().at(block_hash_2).fetch(&registering_query).await;
-    assert!(query_registering_status.unwrap().is_some());
+        .ok_or(UserErr::NoProgramDefined)?
+        .bytecode)
 }
 
 /// Returns a registered user's key visibility
-pub async fn get_key_visibility(
+pub async fn get_registered_details(
     api: &OnlineClient<EntropyConfig>,
     rpc: &LegacyRpcMethods<EntropyConfig>,
     who: &<EntropyConfig as Config>::AccountId,
-) -> Result<KeyVisibility, UserErr> {
+) -> Result<RegisteredInfo<H256, AccountId32>, UserErr> {
     let registered_info_query = entropy::storage().relayer().registered(who);
     let block_hash = rpc
         .chain_get_block_hash(None)
@@ -148,5 +110,5 @@ pub async fn get_key_visibility(
         .fetch(&registered_info_query)
         .await?
         .ok_or_else(|| UserErr::NotRegistering("Register Onchain first"))?;
-    Ok(result.key_visibility.0)
+    Ok(result)
 }

crypto/server/src/helpers/tests.rs

@@ -14,7 +14,7 @@ use subxt::{
     ext::sp_core::{sr25519, Pair},
     tx::PairSigner,
     utils::{AccountId32 as SubxtAccountId32, Static},
-    OnlineClient,
+    Config, OnlineClient,
 };
 use synedrion::KeyShare;
 use testing_utils::substrate_context::testing_context;
@@ -164,19 +164,16 @@ pub async fn spawn_testing_validators(
 
 pub async fn update_programs(
     entropy_api: &OnlineClient<EntropyConfig>,
-    sig_req_keyring: &sr25519::Pair,
     program_modification_account: &sr25519::Pair,
     initial_program: Vec<u8>,
-) {
+) -> <EntropyConfig as Config>::Hash {
     // update/set their programs
-    let update_program_tx = entropy::tx()
-        .programs()
-        .update_program(SubxtAccountId32::from(sig_req_keyring.public()), initial_program);
+    let update_program_tx = entropy::tx().programs().set_program(initial_program);
 
     let program_modification_account =
         PairSigner::<EntropyConfig, sr25519::Pair>::new(program_modification_account.clone());
 
-    entropy_api
+    let in_block = entropy_api
         .tx()
         .sign_and_submit_then_watch_default(&update_program_tx, &program_modification_account)
         .await
@@ -187,6 +184,9 @@ pub async fn update_programs(
         .wait_for_success()
         .await
         .unwrap();
+
+    let result_event = in_block.find_first::<entropy::programs::events::ProgramCreated>().unwrap();
+    result_event.unwrap().program_hash
 }
 
 /// Verify that a Registering account has all confirmation, and that it is registered.

crypto/server/src/signing_client/api.rs

@@ -36,7 +36,7 @@ use crate::{
     chain_api::{entropy, get_api, get_rpc, EntropyConfig},
     helpers::{
         launch::LATEST_BLOCK_NUMBER_PROACTIVE_REFRESH,
-        substrate::{get_key_visibility, get_subgroup, return_all_addresses_of_subgroup},
+        substrate::{get_registered_details, get_subgroup, return_all_addresses_of_subgroup},
         user::{check_in_registration_group, send_key},
         validator::get_signer,
     },
@@ -87,7 +87,11 @@ pub async fn proactive_refresh(
     for key in proactive_refresh_keys {
         let sig_request_address = AccountId32::from_str(&key).map_err(ProtocolErr::StringError)?;
         let key_visibility =
-            get_key_visibility(&api, &rpc, &sig_request_address.clone().into()).await.unwrap();
+            get_registered_details(&api, &rpc, &sig_request_address.clone().into())
+                .await
+                .map_err(|e| ProtocolErr::UserError(e.to_string()))?
+                .key_visibility
+                .0;
         if key_visibility != KeyVisibility::Public && key_visibility != KeyVisibility::Permissioned
         {
             return Ok(StatusCode::ACCEPTED);

crypto/server/src/user/api.rs

@@ -49,7 +49,7 @@ use crate::{
         launch::LATEST_BLOCK_NUMBER_NEW_USER,
         signing::{create_unique_tx_id, do_signing, Hasher},
         substrate::{
-            get_key_visibility, get_program, get_subgroup, return_all_addresses_of_subgroup,
+            get_program, get_registered_details, get_subgroup, return_all_addresses_of_subgroup,
         },
         user::{check_in_registration_group, do_dkg, send_key},
         validator::get_signer,
@@ -106,16 +106,16 @@ pub async fn sign_tx(
 
     let signing_address_arr: [u8; 32] = *signing_address_converted.as_ref();
     let signing_address_subxt = SubxtAccountId32(signing_address_arr);
-    // TODO go back over to simplify accountID type
-    let second_signing_address_conversion = SubxtAccountId32::from_str(&signing_address)
-        .map_err(|_| UserErr::StringError("Account Conversion"))?;
 
     let api = get_api(&app_state.configuration.endpoint).await?;
     let rpc = get_rpc(&app_state.configuration.endpoint).await?;
-
-    let key_visibility = get_key_visibility(&api, &rpc, &second_signing_address_conversion).await?;
-
-    if key_visibility != KeyVisibility::Public && !signed_msg.verify() {
+    let user_details = get_registered_details(
+        &api,
+        &rpc,
+        &SubxtAccountId32::from(signing_address_converted.clone()),
+    )
+    .await?;
+    if user_details.key_visibility.0 != KeyVisibility::Public && !signed_msg.verify() {
         return Err(UserErr::InvalidSignature("Invalid signature."));
     }
     let decrypted_message =
@@ -141,7 +141,7 @@ pub async fn sign_tx(
         recover_key(&api, &rpc, &app_state.kv_store, &signer, signing_address).await?
     }
 
-    let program = get_program(&api, &rpc, &second_signing_address_conversion).await?;
+    let program = get_program(&api, &rpc, &user_details.program_pointer).await?;
 
     let mut runtime = Runtime::new();
     let signature_request = SignatureRequest { message, auxilary_data };
@@ -158,7 +158,7 @@ pub async fn sign_tx(
             &app_state,
             tx_id,
             signing_address_subxt,
-            key_visibility,
+            user_details.key_visibility.0,
         )
         .await
         .map(|signature| {