Fix client coins endpoint to return all asset types (#2984)

## Linked Issues/PRs
Closes #2960 

<!-- List of related issues/PRs -->
## Description
<!-- List of detailed changes -->
This PR fixes the behavior of the `coins` endpoint on the client side.
Previously, if `asset_id` was `None`, it defaulted to
`AssetId::default()`, which is incorrect. The expected behavior (and
what the query side already supports) is to return all assets when
`asset_id` is `None`.
## Checklist
- [ ] Breaking changes are clearly marked as such in the PR description
and changelog
- [ ] New behavior is reflected in tests
- [ ] [The specification](https://github.com/FuelLabs/fuel-specs/)
matches the implemented behavior (link update PR if changes are needed)

### Before requesting review
- [✓] I have reviewed the code myself
- [ ] I have created follow-up issues caused by this PR and linked them
here

### After merging, notify other teams

[Add or remove entries as needed]

- [ ] [Rust SDK](https://github.com/FuelLabs/fuels-rs/)
- [ ] [Sway compiler](https://github.com/FuelLabs/sway/)
- [ ] [Platform
documentation](https://github.com/FuelLabs/devrel-requests/issues/new?assignees=&labels=new+request&projects=&template=NEW-REQUEST.yml&title=%5BRequest%5D%3A+)
(for out-of-organization contributors, the person merging the PR will do
this)
- [ ] Someone else?

---------

Co-authored-by: Green Baneling <[email protected]>

Author: Guocork

.changes/fixed/2984.md

@@ -0,0 +1 @@
+Fix client coins endpoint so that passing `None` for `asset_id` no longer defaults to `AssetId::default()` but correctly returns all asset types.

crates/client/src/client.rs

@@ -1486,10 +1486,7 @@ impl FuelClient {
         request: PaginationRequest<String>,
     ) -> io::Result<PaginatedResult<types::Coin, String>> {
         let owner: schema::Address = (*owner).into();
-        let asset_id: schema::AssetId = match asset_id {
-            Some(asset_id) => (*asset_id).into(),
-            None => schema::AssetId::default(),
-        };
+        let asset_id = asset_id.map(|id| (*id).into());
         let args = CoinsConnectionArgs::from((owner, asset_id, request));
         let query = schema::coins::CoinsQuery::build(args);
 

crates/client/src/client/schema/coins.rs

@@ -59,13 +59,13 @@ pub struct CoinsConnectionArgs {
     pub last: Option<i32>,
 }
 
-impl From<(Address, AssetId, PaginationRequest<String>)> for CoinsConnectionArgs {
-    fn from(r: (Address, AssetId, PaginationRequest<String>)) -> Self {
+impl From<(Address, Option<AssetId>, PaginationRequest<String>)> for CoinsConnectionArgs {
+    fn from(r: (Address, Option<AssetId>, PaginationRequest<String>)) -> Self {
         match r.2.direction {
             PageDirection::Forward => CoinsConnectionArgs {
                 filter: CoinFilterInput {
                     owner: r.0,
-                    asset_id: Some(r.1),
+                    asset_id: r.1,
                 },
                 after: r.2.cursor,
                 before: None,
@@ -75,7 +75,7 @@ impl From<(Address, AssetId, PaginationRequest<String>)> for CoinsConnectionArgs
             PageDirection::Backward => CoinsConnectionArgs {
                 filter: CoinFilterInput {
                     owner: r.0,
-                    asset_id: Some(r.1),
+                    asset_id: r.1,
                 },
                 after: None,
                 before: r.2.cursor,

tests/tests/coin.rs

@@ -175,3 +175,48 @@ async fn get_coins_forwards_backwards(
     assert!(!coins.results.is_empty());
     assert_eq!(coins.results.len(), 10);
 }
+
+#[tokio::test]
+async fn returns_all_assets_when_asset_id_is_none() {
+    let owner = Address::default();
+    let asset_id_a = AssetId::from([1u8; 32]);
+    let asset_id_b = AssetId::from([2u8; 32]);
+
+    // Generate coins with different assets—like 5 of asset A and 5 of asset B
+    let mut coin_generator = CoinConfigGenerator::new();
+    let coins: Vec<_> = (0..10usize)
+        .map(|i| CoinConfig {
+            owner,
+            amount: (i + 1) as Word,
+            asset_id: if i <= 5 { asset_id_a } else { asset_id_b },
+            ..coin_generator.generate()
+        })
+        .collect();
+
+    // setup server & client
+    let srv = setup_service(coins).await;
+    let client = FuelClient::from(srv.bound_address);
+
+    // Query coins where the `asset_id` is `None`.
+    let coins = client
+        .coins(
+            &owner,
+            None,
+            PaginationRequest {
+                cursor: None,
+                results: 10,
+                direction: PageDirection::Forward,
+            },
+        )
+        .await
+        .unwrap();
+
+    // Collect all the `asset_id`s.
+    let asset_ids: std::collections::HashSet<AssetId> =
+        coins.results.iter().map(|c| c.asset_id).collect();
+
+    // run test
+    assert!(asset_ids.contains(&asset_id_a));
+    assert!(asset_ids.contains(&asset_id_b));
+    assert_eq!(coins.results.len(), 10);
+}