token_type filter added in search_asset rpc method

das_api/src/api/api_impl.rs

@@ -374,6 +374,7 @@ impl ApiContract for DasApi {
             negate,
             condition_type,
             interface,
+            token_type,
             owner_address,
             owner_type,
             creator_address,
@@ -403,7 +404,7 @@ impl ApiContract for DasApi {
 
         // Deserialize search assets query
         let spec: Option<(SpecificationVersions, SpecificationAssetClass)> =
-            interface.map(|x| x.into());
+            interface.clone().map(|x| x.into());
         let specification_version = spec.clone().map(|x| x.0);
         let specification_asset_class = spec.map(|x| x.1);
         let condition_type = condition_type.map(|x| match x {
@@ -431,8 +432,10 @@ impl ApiContract for DasApi {
         let saq = SearchAssetsQuery {
             negate,
             condition_type,
+            interface,
             specification_version,
             specification_asset_class,
+            token_type,
             owner_address,
             owner_type,
             creator_address,

das_api/src/api/mod.rs

@@ -1,6 +1,6 @@
 use crate::error::DasApiError;
 use async_trait::async_trait;
-use digital_asset_types::rpc::filter::{AssetSortDirection, SearchConditionType};
+use digital_asset_types::rpc::filter::{AssetSortDirection, SearchConditionType, TokenTypeClass};
 use digital_asset_types::rpc::options::Options;
 use digital_asset_types::rpc::response::{
     AssetList, NftEditions, TokenAccountList, TransactionSignatureList,
@@ -96,6 +96,7 @@ pub struct SearchAssets {
     pub negate: Option<bool>,
     pub condition_type: Option<SearchConditionType>,
     pub interface: Option<Interface>,
+    pub token_type: Option<TokenTypeClass>,
     pub owner_address: Option<String>,
     pub owner_type: Option<OwnershipModel>,
     pub creator_address: Option<String>,

digital_asset_types/src/dao/extensions/asset.rs

@@ -4,6 +4,7 @@ use crate::dao::{
     asset, asset_authority, asset_creators, asset_data, asset_grouping,
     asset_v1_account_attachments,
     sea_orm_active_enums::{OwnerType, RoyaltyTargetType},
+    token_accounts,
 };
 
 #[derive(Copy, Clone, Debug, EnumIter)]
@@ -13,6 +14,7 @@ pub enum Relation {
     AssetAuthority,
     AssetCreators,
     AssetGrouping,
+    TokenAccounts,
 }
 
 impl RelationTrait for Relation {
@@ -22,6 +24,10 @@ impl RelationTrait for Relation {
                 .from(asset::Column::AssetData)
                 .to(asset_data::Column::Id)
                 .into(),
+            Self::TokenAccounts => asset::Entity::belongs_to(token_accounts::Entity)
+                .from(asset::Column::Id)
+                .to(token_accounts::Column::Mint)
+                .into(),
             Self::AssetV1AccountAttachments => {
                 asset::Entity::has_many(asset_v1_account_attachments::Entity).into()
             }
@@ -62,6 +68,12 @@ impl Related<asset_grouping::Entity> for asset::Entity {
     }
 }
 
+impl Related<token_accounts::Entity> for asset::Entity {
+    fn to() -> RelationDef {
+        Relation::TokenAccounts.def()
+    }
+}
+
 impl Default for RoyaltyTargetType {
     fn default() -> Self {
         Self::Creators

digital_asset_types/src/dao/extensions/mod.rs

@@ -5,3 +5,4 @@ pub mod asset_data;
 pub mod asset_grouping;
 pub mod asset_v1_account_attachment;
 pub mod instruction;
+pub mod token_accounts;

digital_asset_types/src/dao/extensions/token_accounts.rs

@@ -0,0 +1,26 @@
+use sea_orm::{EntityTrait, EnumIter, Related, RelationDef, RelationTrait};
+
+use crate::dao::{asset, token_accounts};
+
+#[derive(Copy, Clone, Debug, EnumIter)]
+
+pub enum Relation {
+    Asset,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Asset => token_accounts::Entity::belongs_to(asset::Entity)
+                .from(token_accounts::Column::Mint)
+                .to(asset::Column::Id)
+                .into(),
+        }
+    }
+}
+
+impl Related<asset::Entity> for token_accounts::Entity {
+    fn to() -> RelationDef {
+        Relation::Asset.def()
+    }
+}

digital_asset_types/src/dao/mod.rs

@@ -2,6 +2,8 @@
 mod full_asset;
 mod generated;
 pub mod scopes;
+use crate::rpc::{filter::TokenTypeClass, Interface};
+
 use self::sea_orm_active_enums::{
     OwnerType, RoyaltyTargetType, SpecificationAssetClass, SpecificationVersions,
 };
@@ -52,8 +54,10 @@ pub struct SearchAssetsQuery {
     pub negate: Option<bool>,
     /// Defaults to [ConditionType::All]
     pub condition_type: Option<ConditionType>,
+    pub interface: Option<Interface>,
     pub specification_version: Option<SpecificationVersions>,
     pub specification_asset_class: Option<SpecificationAssetClass>,
+    pub token_type: Option<TokenTypeClass>,
     pub owner_address: Option<Vec<u8>>,
     pub owner_type: Option<OwnerType>,
     pub creator_address: Option<Vec<u8>>,
@@ -75,6 +79,28 @@ pub struct SearchAssetsQuery {
 }
 
 impl SearchAssetsQuery {
+    pub fn validation_checks(&self) -> Result<(), DbErr> {
+        if self.token_type.is_some() {
+            if self.owner_type.is_some() {
+                return Err(DbErr::Custom(
+                    "`owner_type` is not supported when using `token_type` field".to_string(),
+                ));
+            }
+            if self.owner_address.is_none() {
+                return Err(DbErr::Custom(
+                    "Must provide `owner_address` when using `token_type` field".to_string(),
+                ));
+            }
+            if self.interface.is_some() {
+                return Err(DbErr::Custom(
+                    "`specification_asset_class` is not supported when using `token_type` field"
+                        .to_string(),
+                ));
+            }
+        }
+        Ok(())
+    }
+
     pub fn conditions(&self) -> Result<(Condition, Vec<RelationDef>), DbErr> {
         let mut conditions = match self.condition_type {
             // None --> default to all when no option is provided
@@ -88,16 +114,36 @@ impl SearchAssetsQuery {
                     .clone()
                     .map(|x| asset::Column::SpecificationVersion.eq(x)),
             )
+            .add_option({
+                self.validation_checks()?;
+                self.token_type.as_ref().map(|x| match x {
+                    TokenTypeClass::Compressed => asset::Column::TreeId.is_not_null(),
+                    TokenTypeClass::Nft => asset::Column::TreeId.is_null().and(
+                        asset::Column::SpecificationAssetClass
+                            .eq(SpecificationAssetClass::Nft)
+                            .or(asset::Column::SpecificationAssetClass
+                                .eq(SpecificationAssetClass::MplCoreAsset))
+                            .or(asset::Column::SpecificationAssetClass
+                                .eq(SpecificationAssetClass::ProgrammableNft)),
+                    ),
+                    TokenTypeClass::NonFungible => asset::Column::SpecificationAssetClass
+                        .eq(SpecificationAssetClass::Nft)
+                        .or(asset::Column::SpecificationAssetClass
+                            .eq(SpecificationAssetClass::ProgrammableNft))
+                        .or(asset::Column::SpecificationAssetClass
+                            .eq(SpecificationAssetClass::MplCoreAsset)),
+                    TokenTypeClass::Fungible => asset::Column::SpecificationAssetClass
+                        .eq(SpecificationAssetClass::FungibleAsset)
+                        .or(asset::Column::SpecificationAssetClass
+                            .eq(SpecificationAssetClass::FungibleToken)),
+                    TokenTypeClass::All => asset::Column::SpecificationAssetClass.is_not_null(),
+                })
+            })
             .add_option(
                 self.specification_asset_class
                     .clone()
                     .map(|x| asset::Column::SpecificationAssetClass.eq(x)),
             )
-            .add_option(
-                self.owner_address
-                    .to_owned()
-                    .map(|x| asset::Column::Owner.eq(x)),
-            )
             .add_option(
                 self.delegate
                     .to_owned()
@@ -145,16 +191,34 @@ impl SearchAssetsQuery {
         if let Some(o) = self.owner_type.clone() {
             conditions = conditions.add(asset::Column::OwnerType.eq(o));
         } else {
-            // Default to NFTs
-            //
-            // In theory, the owner_type=single check should be sufficient,
-            // however there is an old bug that has marked some non-NFTs as "single" with supply > 1.
-            // The supply check guarentees we do not include those.
-            conditions = conditions.add_option(Some(
-                asset::Column::OwnerType
-                    .eq(OwnerType::Single)
-                    .and(asset::Column::Supply.lte(1)),
-            ));
+            match self.token_type {
+                Some(TokenTypeClass::Fungible) => {
+                    conditions = conditions.add_option(Some(
+                        asset::Column::OwnerType.eq(OwnerType::Token).and(
+                            (asset::Column::SpecificationAssetClass
+                                .eq(SpecificationAssetClass::FungibleToken))
+                            .or(asset::Column::SpecificationAssetClass
+                                .eq(SpecificationAssetClass::FungibleAsset)),
+                        ),
+                    ));
+                }
+                Some(TokenTypeClass::All) => {
+                    conditions = conditions
+                        .add_option(Some(asset::Column::SpecificationAssetClass.is_not_null()));
+                }
+                _ => {
+                    // Default to NFTs
+                    //
+                    // In theory, the owner_type=single check should be sufficient,
+                    // however there is an old bug that has marked some non-NFTs as "single" with supply > 1.
+                    // The supply check guarentees we do not include those.
+                    conditions = conditions.add_option(Some(
+                        asset::Column::OwnerType
+                            .eq(OwnerType::Single)
+                            .and(asset::Column::Supply.lte(1)),
+                    ));
+                }
+            }
         }
 
         if let Some(c) = self.creator_address.to_owned() {
@@ -194,6 +258,31 @@ impl SearchAssetsQuery {
             joins.push(rel);
         }
 
+        if let Some(o) = self.owner_address.to_owned() {
+            if self.token_type == Some(TokenTypeClass::Fungible)
+                || self.token_type == Some(TokenTypeClass::All)
+            {
+                conditions = conditions.add(
+                    asset::Column::Owner
+                        .eq(o.clone())
+                        .or(token_accounts::Column::Owner.eq(o)),
+                );
+
+                let rel = extensions::token_accounts::Relation::Asset
+                    .def()
+                    .rev()
+                    .on_condition(|left, right| {
+                        Expr::tbl(right, token_accounts::Column::Mint)
+                            .eq(Expr::tbl(left, asset::Column::Id))
+                            .into_condition()
+                    });
+                println!("rel: {:?}", rel);
+                joins.push(rel);
+            } else {
+                conditions = conditions.add(asset::Column::Owner.eq(o));
+            }
+        }
+
         if let Some(g) = self.grouping.to_owned() {
             let cond = Condition::all()
                 .add(asset_grouping::Column::GroupKey.eq(g.0))

digital_asset_types/src/rpc/filter.rs

@@ -1,4 +1,5 @@
 use schemars::JsonSchema;
+use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
@@ -31,6 +32,15 @@ pub enum AssetSortBy {
     None,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, Serialize, Deserialize, JsonSchema)]
+pub enum TokenTypeClass {
+    Fungible,
+    NonFungible,
+    Compressed,
+    Nft,
+    All,
+}
+
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
 pub enum AssetSortDirection {
     #[serde(rename = "asc")]

integration_tests/tests/data/largest_token_account_ids/2w81QrLYTwSDkNwXgCqKAwrC1Tu6R9mh9BHcxys2Bup2/2w81QrLYTwSDkNwXgCqKAwrC1Tu6R9mh9BHcxys2Bup2

@@ -0,0 +1,2 @@
+
+�Ÿ���9����mR�i\���꠽�]�

integration_tests/tests/data/largest_token_account_ids/42AYryUGNmJMe9ycBXZekkYvdTehgbtECHs7SLu5JJTB/42AYryUGNmJMe9ycBXZekkYvdTehgbtECHs7SLu5JJTB

@@ -0,0 +1,2 @@
+e9;�:�$f��E�v�KA�
+��\�%.��
�

integration_tests/tests/data/largest_token_account_ids/AH6VcoSbCGGv8BHeN7K766VUWMcdFRTaXpLvGTLSdAmk/AH6VcoSbCGGv8BHeN7K766VUWMcdFRTaXpLvGTLSdAmk

@@ -0,0 +1 @@
+.B�Q�*pp-���U������g����>�

integration_tests/tests/integration_tests/main.rs

@@ -9,3 +9,4 @@ mod regular_nft_tests;
 mod show_inscription_flag_tests;
 mod test_show_zero_balance_filter;
 mod token_accounts_tests;
+mod token_type_filter_test;