chore: update agent to 686c249

Cargo.toml

@@ -25,11 +25,11 @@ needless_lifetimes = "allow"
 candid = "0.10.11"
 candid_parser = "0.1.4"
 dfx-core = { path = "src/dfx-core", version = "0.1.0" }
-ic-agent = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "b53d770cfd07df07b1024cfd9cc25f7ff80d1b76" }
+ic-agent = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "686c249adb80aac58b466e654827d8b9dcfe00f4" }
 ic-asset = { path = "src/canisters/frontend/ic-asset", version = "0.22.0" }
 ic-cdk = "0.13.1"
-ic-identity-hsm = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "b53d770cfd07df07b1024cfd9cc25f7ff80d1b76" }
-ic-utils = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "b53d770cfd07df07b1024cfd9cc25f7ff80d1b76" }
+ic-identity-hsm = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "686c249adb80aac58b466e654827d8b9dcfe00f4" }
+ic-utils = { version = "0.40", git = "https://github.com/dfinity/agent-rs", rev = "686c249adb80aac58b466e654827d8b9dcfe00f4" }
 
 aes-gcm = { version = "0.10.3", features = ["std"] }
 anyhow = "1.0.56"

src/canisters/frontend/ic-asset/src/batch_upload/retryable.rs

@@ -1,17 +1,23 @@
+use ic_agent::agent::OperationStatus;
 use ic_agent::export::reqwest::StatusCode;
-use ic_agent::AgentError;
+use ic_utils::error::{BaseError, CanisterError};
 
-pub(crate) fn retryable(agent_error: &AgentError) -> bool {
-    match agent_error {
-        AgentError::TimeoutWaitingForResponse() => true,
-        AgentError::TransportError(_) => true,
-        AgentError::HttpError(http_error) => {
-            http_error.status == StatusCode::INTERNAL_SERVER_ERROR
-                || http_error.status == StatusCode::BAD_GATEWAY
-                || http_error.status == StatusCode::SERVICE_UNAVAILABLE
-                || http_error.status == StatusCode::GATEWAY_TIMEOUT
-                || http_error.status == StatusCode::TOO_MANY_REQUESTS
-        }
-        _ => false,
+pub(crate) fn retryable(canister_error: &BaseError) -> bool {
+    let Some(agent_error) = canister_error.as_agent() else {
+        return false;
+    };
+    if agent_error
+        .operation_info()
+        .is_some_and(|op| op.status == OperationStatus::NotSent)
+    {
+        true
+    } else if let Some(http_error) = agent_error.as_http_error() {
+        http_error.status == StatusCode::INTERNAL_SERVER_ERROR
+            || http_error.status == StatusCode::BAD_GATEWAY
+            || http_error.status == StatusCode::SERVICE_UNAVAILABLE
+            || http_error.status == StatusCode::GATEWAY_TIMEOUT
+            || http_error.status == StatusCode::TOO_MANY_REQUESTS
+    } else {
+        false
     }
 }

src/canisters/frontend/ic-asset/src/canister_api/methods/asset_properties.rs

@@ -11,8 +11,8 @@ use crate::{
 use backoff::backoff::Backoff;
 use backoff::ExponentialBackoffBuilder;
 use futures_intrusive::sync::SharedSemaphore;
-use ic_agent::{agent::RejectResponse, AgentError};
 use ic_utils::call::SyncCall;
+use ic_utils::error::{BaseError, CanisterError};
 use ic_utils::Canister;
 use std::{collections::HashMap, time::Duration};
 
@@ -51,12 +51,12 @@ pub(crate) async fn get_assets_properties(
                         }
                         break Ok(asset_properties);
                     }
-                    Err(agent_err) if !retryable(&agent_err) => {
-                        break Err(agent_err);
+                    Err(canister_err) if !retryable(&canister_err) => {
+                        break Err(canister_err);
                     }
-                    Err(agent_err) => match retry_policy.next_backoff() {
+                    Err(canister_err) => match retry_policy.next_backoff() {
                         Some(duration) => tokio::time::sleep(duration).await,
-                        None => break Err(agent_err),
+                        None => break Err(canister_err),
                     },
                 };
             }
@@ -73,12 +73,14 @@ pub(crate) async fn get_assets_properties(
             }
             // older canisters don't have get_assets_properties method
             // therefore we can break the loop
-            Err(AgentError::UncertifiedReject {
-                reject: RejectResponse { reject_message, .. },
-                ..
-            }) if reject_message
-                .contains(&format!("has no query method '{GET_ASSET_PROPERTIES}'"))
-                || reject_message.contains("query method does not exist") =>
+            Err(err)
+                if err.as_agent().is_some_and(|err| {
+                    err.as_reject().is_some_and(|err| {
+                        err.reject_message
+                            .contains(&format!("has no query method '{GET_ASSET_PROPERTIES}'"))
+                            || err.reject_message.contains("query method does not exist")
+                    })
+                }) =>
             {
                 break;
             }
@@ -94,7 +96,7 @@ pub(crate) async fn get_assets_properties(
 pub(crate) async fn get_asset_properties(
     canister: &Canister<'_>,
     asset_id: &str,
-) -> Result<AssetProperties, AgentError> {
+) -> Result<AssetProperties, BaseError> {
     let (asset_properties,): (AssetProperties,) = canister
         .query(GET_ASSET_PROPERTIES)
         .with_arg(GetAssetPropertiesArgument(asset_id.to_string()))

src/canisters/frontend/ic-asset/src/canister_api/methods/batch.rs

@@ -8,12 +8,12 @@ use crate::canister_api::types::batch_upload::common::{
 use backoff::backoff::Backoff;
 use backoff::ExponentialBackoffBuilder;
 use candid::{CandidType, Nat};
-use ic_agent::AgentError;
+use ic_utils::error::BaseError;
 use ic_utils::Canister;
 use serde_bytes::ByteBuf;
 use std::time::Duration;
 
-pub(crate) async fn create_batch(canister: &Canister<'_>) -> Result<Nat, AgentError> {
+pub(crate) async fn create_batch(canister: &Canister<'_>) -> Result<Nat, BaseError> {
     let mut retry_policy = ExponentialBackoffBuilder::new()
         .with_initial_interval(Duration::from_secs(1))
         .with_max_interval(Duration::from_secs(16))
@@ -31,12 +31,12 @@ pub(crate) async fn create_batch(canister: &Canister<'_>) -> Result<Nat, AgentEr
             .await;
         match response {
             Ok((batch_id,)) => break Ok(batch_id),
-            Err(agent_err) if !retryable(&agent_err) => {
-                break Err(agent_err);
+            Err(canister_err) if !retryable(&canister_err) => {
+                break Err(canister_err);
             }
-            Err(agent_err) => match retry_policy.next_backoff() {
+            Err(canister_err) => match retry_policy.next_backoff() {
                 Some(duration) => tokio::time::sleep(duration).await,
-                None => break Err(agent_err),
+                None => break Err(canister_err),
             },
         };
     }?;
@@ -47,7 +47,7 @@ pub(crate) async fn submit_commit_batch<T: CandidType + Sync>(
     canister: &Canister<'_>,
     method_name: &str,
     arg: T, // CommitBatchArguments_{v0,v1,etc}
-) -> Result<(), AgentError> {
+) -> Result<(), BaseError> {
     let mut retry_policy = ExponentialBackoffBuilder::new()
         .with_initial_interval(Duration::from_secs(1))
         .with_max_interval(Duration::from_secs(16))
@@ -58,12 +58,12 @@ pub(crate) async fn submit_commit_batch<T: CandidType + Sync>(
     loop {
         match canister.update(method_name).with_arg(&arg).build().await {
             Ok(()) => return Ok(()),
-            Err(agent_err) if !retryable(&agent_err) => {
-                return Err(agent_err);
+            Err(canister_err) if !retryable(&canister_err) => {
+                return Err(canister_err);
             }
-            Err(agent_err) => match retry_policy.next_backoff() {
+            Err(canister_err) => match retry_policy.next_backoff() {
                 Some(duration) => tokio::time::sleep(duration).await,
-                None => return Err(agent_err),
+                None => return Err(canister_err),
             },
         }
     }
@@ -72,21 +72,21 @@ pub(crate) async fn submit_commit_batch<T: CandidType + Sync>(
 pub(crate) async fn commit_batch<T: CandidType + Sync>(
     canister: &Canister<'_>,
     arg: T, // CommitBatchArguments_{v0,v1,etc}
-) -> Result<(), AgentError> {
+) -> Result<(), BaseError> {
     submit_commit_batch(canister, COMMIT_BATCH, arg).await
 }
 
 pub(crate) async fn propose_commit_batch<T: CandidType + Sync>(
     canister: &Canister<'_>,
     arg: T, // CommitBatchArguments_{v0,v1,etc}
-) -> Result<(), AgentError> {
+) -> Result<(), BaseError> {
     submit_commit_batch(canister, PROPOSE_COMMIT_BATCH, arg).await
 }
 
 pub(crate) async fn compute_evidence(
     canister: &Canister<'_>,
     arg: &ComputeEvidenceArguments,
-) -> Result<Option<ByteBuf>, AgentError> {
+) -> Result<Option<ByteBuf>, BaseError> {
     let mut retry_policy = ExponentialBackoffBuilder::new()
         .with_initial_interval(Duration::from_secs(1))
         .with_max_interval(Duration::from_secs(16))
@@ -103,12 +103,12 @@ pub(crate) async fn compute_evidence(
             .await
         {
             Ok(x) => return Ok(x.0),
-            Err(agent_err) if !retryable(&agent_err) => {
-                return Err(agent_err);
+            Err(canister_err) if !retryable(&canister_err) => {
+                return Err(canister_err);
             }
-            Err(agent_err) => match retry_policy.next_backoff() {
+            Err(canister_err) => match retry_policy.next_backoff() {
                 Some(duration) => tokio::time::sleep(duration).await,
-                None => return Err(agent_err),
+                None => return Err(canister_err),
             },
         }
     }

src/canisters/frontend/ic-asset/src/canister_api/methods/chunk.rs

@@ -55,7 +55,7 @@ pub(crate) async fn create_chunk(
                         .and_then(|bytes| Ok((Decode!(&bytes, CreateChunkResponse)?.chunk_id,)))
                 }
             },
-            Err(agent_err) => Err(agent_err),
+            Err(canister_err) => Err(canister_err),
         };
 
         match wait_result {
@@ -65,12 +65,12 @@ pub(crate) async fn create_chunk(
                 }
                 return Ok(chunk_id);
             }
-            Err(agent_err) if !retryable(&agent_err) => {
-                return Err(CreateChunkError::CreateChunk(agent_err));
+            Err(canister_err) if !retryable(&canister_err) => {
+                return Err(CreateChunkError::CreateChunk(canister_err));
             }
-            Err(agent_err) => match retry_policy.next_backoff() {
+            Err(canister_err) => match retry_policy.next_backoff() {
                 Some(duration) => tokio::time::sleep(duration).await,
-                None => return Err(CreateChunkError::CreateChunk(agent_err)),
+                None => return Err(CreateChunkError::CreateChunk(canister_err)),
             },
         }
     }
@@ -117,7 +117,7 @@ pub(crate) async fn create_chunks(
                         .and_then(|bytes| Ok((Decode!(&bytes, CreateChunksResponse)?.chunk_ids,)))
                 }
             },
-            Err(agent_err) => Err(agent_err),
+            Err(canister_err) => Err(canister_err),
         };
 
         match wait_result {
@@ -127,12 +127,12 @@ pub(crate) async fn create_chunks(
                 }
                 return Ok(chunk_ids);
             }
-            Err(agent_err) if !retryable(&agent_err) => {
-                return Err(CreateChunkError::CreateChunks(agent_err));
+            Err(canister_err) if !retryable(&canister_err) => {
+                return Err(CreateChunkError::CreateChunks(canister_err));
             }
-            Err(agent_err) => match retry_policy.next_backoff() {
+            Err(canister_err) => match retry_policy.next_backoff() {
                 Some(duration) => tokio::time::sleep(duration).await,
-                None => return Err(CreateChunkError::CreateChunks(agent_err)),
+                None => return Err(CreateChunkError::CreateChunks(canister_err)),
             },
         }
     }

src/canisters/frontend/ic-asset/src/canister_api/methods/list.rs

@@ -1,13 +1,13 @@
 use crate::canister_api::methods::method_names::LIST;
 use crate::canister_api::types::{asset::AssetDetails, list::ListAssetsRequest};
-use ic_agent::AgentError;
 use ic_utils::call::SyncCall;
+use ic_utils::error::BaseError;
 use ic_utils::Canister;
 use std::collections::HashMap;
 
 pub(crate) async fn list_assets(
     canister: &Canister<'_>,
-) -> Result<HashMap<String, AssetDetails>, AgentError> {
+) -> Result<HashMap<String, AssetDetails>, BaseError> {
     let (entries,): (Vec<AssetDetails>,) = canister
         .query(LIST)
         .with_arg(ListAssetsRequest {})

src/canisters/frontend/ic-asset/src/error/compute_evidence.rs

@@ -2,7 +2,7 @@ use crate::error::create_project_asset::CreateProjectAssetError;
 use crate::error::gather_asset_descriptors::GatherAssetDescriptorsError;
 use crate::error::get_asset_properties::GetAssetPropertiesError;
 use crate::error::hash_content::HashContentError;
-use ic_agent::AgentError;
+use ic_utils::error::BaseError;
 use thiserror::Error;
 
 use super::AssembleCommitBatchArgumentError;
@@ -32,5 +32,5 @@ pub enum ComputeEvidenceError {
 
     /// Failed to list assets in the asset canister.
     #[error("Failed to list assets")]
-    ListAssets(#[source] AgentError),
+    ListAssets(#[source] BaseError),
 }