prints for testing

.github/workflows/ci-dev.yml

@@ -115,8 +115,8 @@ jobs:
  DEST_STELLAR_SECRET_TESTNET: ${{ secrets.DEST_STELLAR_SECRET_TESTNET }}
  with:
  toolchain: nightly-2024-02-09
- command: test
- args: --all --all-features
+ command: test 
+ args: test_register_vault --all --all-features -- --nocapture
 
  - name: Rustfmt
  if: matrix.rust == 'nightly'

.github/workflows/ci-main.yml

@@ -90,8 +90,8 @@ jobs:
  DEST_STELLAR_SECRET_TESTNET: ${{ secrets.DEST_STELLAR_SECRET_TESTNET }}
  with:
  toolchain: nightly-2024-02-09
- command: test
- args: --all --all-features
+ command: test 
+ args: test_register_vault --all-features -- --nocapture
 
  - name: Rustfmt
  if: matrix.rust == 'nightly'

clients/runtime/client/src/lib.rs

@@ -244,7 +244,7 @@ impl<C: ChainSpec + 'static> SubxtClientConfig<C> {
  offchain_worker: Default::default(),
  prometheus_config: Default::default(),
  rpc_cors: Default::default(),
- rpc_max_connections: Default::default(),
+ rpc_max_connections: 1000,
  rpc_methods: Default::default(),
  tracing_receiver: Default::default(),
  tracing_targets: Default::default(),
@@ -265,7 +265,6 @@ impl<C: ChainSpec + 'static> SubxtClientConfig<C> {
  trie_cache_maximum_size: None,
  blocks_pruning: BlocksPruning::KeepAll,
  };
-
  log::info!("{}", service_config.impl_name);
  log::info!("✌️ version {}", service_config.impl_version);
  log::info!("❤️ by {}, {}", self.author, self.copyright_start_year);

clients/runtime/src/integration/mod.rs

@@ -96,6 +96,12 @@ pub async fn default_provider_client(
  let mut service_config = config.into_service_config();
  service_config.offchain_worker.enabled = true;
 
+ println!("🚀 Starting node with configuration:");
+ println!("📋 Chain specification: {}", service_config.chain_spec.name());
+ println!("Port {:?}", service_config.rpc_port);
+ println!("Address {:?}", service_config.rpc_addr);
+
+
  let (task_manager, rpc_handlers) = if is_public_network {
  testchain::service::start_instant_mainnet(service_config)
  .await
@@ -108,6 +114,8 @@ pub async fn default_provider_client(
 
  let client = SubxtClient::new(task_manager, rpc_handlers);
 
+ println!("Subxt client started");
+
  (client, tmp)
 }
 

clients/runtime/src/retry.rs

@@ -34,15 +34,17 @@ where
 {
  let mut backoff = get_exponential_backoff();
  loop {
+ println!("attempting...");
  let err = match verify(call().await).await {
  Ok(ok) => return Ok(ok),
- Err(RetryPolicy::Skip(err)) => err,
+ Err(RetryPolicy::Skip(err)) =>err,
  Err(RetryPolicy::Throw(err)) => return Err(err),
  };
-
+ println!("retrying... Error: {:?}", err);
  match backoff.next_backoff() {
  Some(wait) => {
  // error occurred, sleep before retrying
+ println!("{} - next retry in {:.3} s", err, wait.as_secs_f64());
  log::warn!("{} - next retry in {:.3} s", err, wait.as_secs_f64());
  tokio::time::sleep(wait).await;
  },

clients/runtime/src/rpc.rs

@@ -126,6 +126,8 @@ impl SpacewalkParachain {
  native_currency_id: CurrencyId::Native,
  relay_chain_currency_id: *relay_chain_currency_id,
  };
+
+ println!("Parachain rpc created");
  Ok(parachain_rpc)
  }
 
@@ -219,11 +221,13 @@ impl SpacewalkParachain {
  match timeout(TRANSACTION_TIMEOUT, async {
  let tx_progress =
  self.api.tx().sign_and_submit_then_watch_default(&call, &*signer).await?;
+ println!("Tx submitted - Waiting for finalized success");
  tx_progress.wait_for_finalized_success().await
  })
  .await
  {
  Err(_) => {
+ println!("Timeout on transaction submission - restart required");
  log::warn!("Timeout on transaction submission - restart required");
  let _ = self.shutdown_tx.send(());
  Err(Error::Timeout)
@@ -235,18 +239,22 @@ impl SpacewalkParachain {
  match result.map_err(Into::<Error>::into) {
  Ok(ok) => Ok(ok),
  Err(err) => match err.is_invalid_transaction() {
- Some(Recoverability::Recoverable(data)) =>
- Err(RetryPolicy::Skip(Error::InvalidTransaction(data))),
+ Some(Recoverability::Recoverable(data)) =>{
+ println!("Invalid transaction - retrying transaction");
+ Err(RetryPolicy::Skip(Error::InvalidTransaction(data)))},
  Some(Recoverability::Unrecoverable(data)) =>
  Err(RetryPolicy::Throw(Error::InvalidTransaction(data))),
  None => {
  // Handle other errors
  if err.is_pool_too_low_priority() {
+ println!("Pool too low priority - retrying transaction");
  Err(RetryPolicy::Skip(Error::PoolTooLowPriority))
  } else if err.is_block_hash_not_found_error() {
+ println!("Block hash not found - retrying transaction");
  log::info!("Re-sending transaction after apparent fork");
  Err(RetryPolicy::Skip(Error::BlockHashNotFound))
  } else if err.is_timeout_error() {
+ println!("Timeout inner error - retrying transaction");
  Err(RetryPolicy::Skip(Error::Timeout))
  } else {
  Err(RetryPolicy::Throw(err))
@@ -888,6 +896,7 @@ impl OraclePallet for SpacewalkParachain {
 
  let mut coin_infos = vec![];
  for ((blockchain, symbol), price) in values {
+ println!("Setting price for {:?}/{:?} to {:?}", blockchain, symbol, price);
  log::info!("Setting price for {:?}/{:?} to {:?}", blockchain, symbol, price);
  let coin_info = CoinInfo {
  symbol: symbol.clone(),

clients/runtime/src/tests.rs

@@ -115,6 +115,7 @@ async fn test_register_vault() {
  let (client, _tmp_dir) =
  default_provider_client(AccountKeyring::Alice, is_public_network).await;
  let parachain_rpc = setup_provider(client.clone(), AccountKeyring::Alice).await;
+
  set_exchange_rate(client.clone()).await;
 
  let vault_id = VaultId::new(
@@ -123,8 +124,11 @@ async fn test_register_vault() {
  DEFAULT_WRAPPED_CURRENCY,
  );
 
+ println!("Register pk");
  parachain_rpc.register_public_key(dummy_public_key()).await.unwrap();
+ println!("Register vault");
  parachain_rpc.register_vault(&vault_id, 3 * 10u128.pow(12)).await.unwrap();
+ println!("Getting vault");
  parachain_rpc.get_vault(&vault_id).await.unwrap();
  assert_eq!(parachain_rpc.get_public_key().await.unwrap(), Some(dummy_public_key()));
 }