Change creator and collection verification to use upserts to support out of order

README.md

@@ -38,6 +38,10 @@ Then with a local `DATABASE_URL` var exported like this `export DATABASE_URL=pos
 
 If you need to install `sea-orm-cli` run `cargo install sea-orm-cli`.
 
+Note: The current SeaORM types were generated using version 0.9.3 so unless you want to upgrade you can install using `cargo install sea-orm-cli --version 0.9.3`.
+
+Also note: The migration `m20230224_093722_performance_improvements` needs to be commented out of the migration lib.rs in order for the Sea ORM `Relations` to generate correctly.
+
 #### Developing Locally
  *Prerequisites*
  * A Postgres Server running with the database setup according to ./init.sql

digital_asset_types/src/dao/generated/asset.rs

@@ -20,8 +20,8 @@ impl EntityName for Entity {
 pub struct Model {
     pub id: Vec<u8>,
     pub alt_id: Option<Vec<u8>>,
-    pub specification_version: SpecificationVersions,
-    pub specification_asset_class: SpecificationAssetClass,
+    pub specification_version: Option<SpecificationVersions>,
+    pub specification_asset_class: Option<SpecificationAssetClass>,
     pub owner: Option<Vec<u8>>,
     pub owner_type: OwnerType,
     pub delegate: Option<Vec<u8>>,
@@ -30,19 +30,22 @@ pub struct Model {
     pub supply_mint: Option<Vec<u8>>,
     pub compressed: bool,
     pub compressible: bool,
-    pub seq: i64,
+    pub seq: Option<i64>,
     pub tree_id: Option<Vec<u8>>,
     pub leaf: Option<Vec<u8>>,
-    pub nonce: i64,
+    pub nonce: Option<i64>,
     pub royalty_target_type: RoyaltyTargetType,
     pub royalty_target: Option<Vec<u8>>,
     pub royalty_amount: i32,
     pub asset_data: Option<Vec<u8>>,
     pub created_at: Option<DateTimeWithTimeZone>,
     pub burnt: bool,
-    pub slot_updated: i64,
+    pub slot_updated: Option<i64>,
     pub data_hash: Option<String>,
     pub creator_hash: Option<String>,
+    pub owner_delegate_seq: Option<i64>,
+    pub was_decompressed: bool,
+    pub leaf_seq: Option<i64>,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
@@ -72,6 +75,9 @@ pub enum Column {
     SlotUpdated,
     DataHash,
     CreatorHash,
+    OwnerDelegateSeq,
+    WasDecompressed,
+    LeafSeq,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DerivePrimaryKey)]
@@ -101,8 +107,8 @@ impl ColumnTrait for Column {
         match self {
             Self::Id => ColumnType::Binary.def(),
             Self::AltId => ColumnType::Binary.def().null(),
-            Self::SpecificationVersion => SpecificationVersions::db_type(),
-            Self::SpecificationAssetClass => SpecificationAssetClass::db_type(),
+            Self::SpecificationVersion => SpecificationVersions::db_type().null(),
+            Self::SpecificationAssetClass => SpecificationAssetClass::db_type().null(),
             Self::Owner => ColumnType::Binary.def().null(),
             Self::OwnerType => OwnerType::db_type(),
             Self::Delegate => ColumnType::Binary.def().null(),
@@ -111,19 +117,22 @@ impl ColumnTrait for Column {
             Self::SupplyMint => ColumnType::Binary.def().null(),
             Self::Compressed => ColumnType::Boolean.def(),
             Self::Compressible => ColumnType::Boolean.def(),
-            Self::Seq => ColumnType::BigInteger.def(),
+            Self::Seq => ColumnType::BigInteger.def().null(),
             Self::TreeId => ColumnType::Binary.def().null(),
             Self::Leaf => ColumnType::Binary.def().null(),
-            Self::Nonce => ColumnType::BigInteger.def(),
+            Self::Nonce => ColumnType::BigInteger.def().null(),
             Self::RoyaltyTargetType => RoyaltyTargetType::db_type(),
             Self::RoyaltyTarget => ColumnType::Binary.def().null(),
             Self::RoyaltyAmount => ColumnType::Integer.def(),
             Self::AssetData => ColumnType::Binary.def().null(),
             Self::CreatedAt => ColumnType::TimestampWithTimeZone.def().null(),
             Self::Burnt => ColumnType::Boolean.def(),
-            Self::SlotUpdated => ColumnType::BigInteger.def(),
+            Self::SlotUpdated => ColumnType::BigInteger.def().null(),
             Self::DataHash => ColumnType::Char(Some(50u32)).def().null(),
             Self::CreatorHash => ColumnType::Char(Some(50u32)).def().null(),
+            Self::OwnerDelegateSeq => ColumnType::BigInteger.def().null(),
+            Self::WasDecompressed => ColumnType::Boolean.def(),
+            Self::LeafSeq => ColumnType::BigInteger.def().null(),
         }
     }
 }

digital_asset_types/src/dao/generated/asset_creators.rs

@@ -19,8 +19,8 @@ pub struct Model {
     pub creator: Vec<u8>,
     pub share: i32,
     pub verified: bool,
-    pub seq: i64,
-    pub slot_updated: i64,
+    pub seq: Option<i64>,
+    pub slot_updated: Option<i64>,
     pub position: i16,
 }
 
@@ -62,8 +62,8 @@ impl ColumnTrait for Column {
             Self::Creator => ColumnType::Binary.def(),
             Self::Share => ColumnType::Integer.def(),
             Self::Verified => ColumnType::Boolean.def(),
-            Self::Seq => ColumnType::BigInteger.def(),
-            Self::SlotUpdated => ColumnType::BigInteger.def(),
+            Self::Seq => ColumnType::BigInteger.def().null(),
+            Self::SlotUpdated => ColumnType::BigInteger.def().null(),
             Self::Position => ColumnType::SmallInteger.def(),
         }
     }

digital_asset_types/src/dao/generated/sea_orm_active_enums.rs

@@ -3,6 +3,44 @@
 use sea_orm::entity::prelude::*;
 use serde::{Deserialize, Serialize};
 
+#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "mutability")]
+pub enum Mutability {
+    #[sea_orm(string_value = "immutable")]
+    Immutable,
+    #[sea_orm(string_value = "mutable")]
+    Mutable,
+    #[sea_orm(string_value = "unknown")]
+    Unknown,
+}
+#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
+#[sea_orm(
+    rs_type = "String",
+    db_type = "Enum",
+    enum_name = "specification_asset_class"
+)]
+pub enum SpecificationAssetClass {
+    #[sea_orm(string_value = "FUNGIBLE_ASSET")]
+    FungibleAsset,
+    #[sea_orm(string_value = "FUNGIBLE_TOKEN")]
+    FungibleToken,
+    #[sea_orm(string_value = "IDENTITY_NFT")]
+    IdentityNft,
+    #[sea_orm(string_value = "NFT")]
+    Nft,
+    #[sea_orm(string_value = "NON_TRANSFERABLE_NFT")]
+    NonTransferableNft,
+    #[sea_orm(string_value = "PRINT")]
+    Print,
+    #[sea_orm(string_value = "PRINTABLE_NFT")]
+    PrintableNft,
+    #[sea_orm(string_value = "PROGRAMMABLE_NFT")]
+    ProgrammableNft,
+    #[sea_orm(string_value = "TRANSFER_RESTRICTED_NFT")]
+    TransferRestrictedNft,
+    #[sea_orm(string_value = "unknown")]
+    Unknown,
+}
 #[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
 #[sea_orm(
     rs_type = "String",
@@ -20,6 +58,34 @@ pub enum SpecificationVersions {
     V2,
 }
 #[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
+#[sea_orm(
+    rs_type = "String",
+    db_type = "Enum",
+    enum_name = "v1_account_attachments"
+)]
+pub enum V1AccountAttachments {
+    #[sea_orm(string_value = "edition")]
+    Edition,
+    #[sea_orm(string_value = "edition_marker")]
+    EditionMarker,
+    #[sea_orm(string_value = "master_edition_v1")]
+    MasterEditionV1,
+    #[sea_orm(string_value = "master_edition_v2")]
+    MasterEditionV2,
+    #[sea_orm(string_value = "unknown")]
+    Unknown,
+}
+#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "owner_type")]
+pub enum OwnerType {
+    #[sea_orm(string_value = "single")]
+    Single,
+    #[sea_orm(string_value = "token")]
+    Token,
+    #[sea_orm(string_value = "unknown")]
+    Unknown,
+}
+#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
 #[sea_orm(
     rs_type = "String",
     db_type = "Enum",
@@ -57,69 +123,3 @@ pub enum ChainMutability {
     #[sea_orm(string_value = "unknown")]
     Unknown,
 }
-#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
-#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "owner_type")]
-pub enum OwnerType {
-    #[sea_orm(string_value = "single")]
-    Single,
-    #[sea_orm(string_value = "token")]
-    Token,
-    #[sea_orm(string_value = "unknown")]
-    Unknown,
-}
-#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
-#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "mutability")]
-pub enum Mutability {
-    #[sea_orm(string_value = "immutable")]
-    Immutable,
-    #[sea_orm(string_value = "mutable")]
-    Mutable,
-    #[sea_orm(string_value = "unknown")]
-    Unknown,
-}
-#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
-#[sea_orm(
-    rs_type = "String",
-    db_type = "Enum",
-    enum_name = "v1_account_attachments"
-)]
-pub enum V1AccountAttachments {
-    #[sea_orm(string_value = "edition")]
-    Edition,
-    #[sea_orm(string_value = "edition_marker")]
-    EditionMarker,
-    #[sea_orm(string_value = "master_edition_v1")]
-    MasterEditionV1,
-    #[sea_orm(string_value = "master_edition_v2")]
-    MasterEditionV2,
-    #[sea_orm(string_value = "unknown")]
-    Unknown,
-}
-#[derive(Debug, Clone, PartialEq, EnumIter, DeriveActiveEnum, Serialize, Deserialize)]
-#[sea_orm(
-    rs_type = "String",
-    db_type = "Enum",
-    enum_name = "specification_asset_class"
-)]
-pub enum SpecificationAssetClass {
-    #[sea_orm(string_value = "FUNGIBLE_ASSET")]
-    FungibleAsset,
-    #[sea_orm(string_value = "FUNGIBLE_TOKEN")]
-    FungibleToken,
-    #[sea_orm(string_value = "IDENTITY_NFT")]
-    IdentityNft,
-    #[sea_orm(string_value = "NFT")]
-    Nft,
-    #[sea_orm(string_value = "NON_TRANSFERABLE_NFT")]
-    NonTransferableNft,
-    #[sea_orm(string_value = "PRINT")]
-    Print,
-    #[sea_orm(string_value = "PRINTABLE_NFT")]
-    PrintableNft,
-    #[sea_orm(string_value = "TRANSFER_RESTRICTED_NFT")]
-    TransferRestrictedNft,
-    #[sea_orm(string_value = "unknown")]
-    Unknown,
-    #[sea_orm(string_value = "PNFT")]
-    ProgrammableNft,
-}

digital_asset_types/src/dapi/common/asset.rs

@@ -1,7 +1,7 @@
 use crate::dao::sea_orm_active_enums::SpecificationVersions;
+use crate::dao::FullAsset;
 use crate::dao::Pagination;
 use crate::dao::{asset, asset_authority, asset_creators, asset_data, asset_grouping};
-use crate::dao::FullAsset;
 
 use crate::rpc::filter::{AssetSortBy, AssetSortDirection, AssetSorting};
 use crate::rpc::response::{AssetError, AssetList};
@@ -221,9 +221,11 @@ pub fn v1_content_from_json(asset_data: &asset_data::Model) -> Result<Content, D
 
 pub fn get_content(asset: &asset::Model, data: &asset_data::Model) -> Result<Content, DbErr> {
     match asset.specification_version {
-        SpecificationVersions::V1 => v1_content_from_json(data),
-        SpecificationVersions::V0 => v1_content_from_json(data),
-        _ => Err(DbErr::Custom("Version Not Implemented".to_string())),
+        Some(SpecificationVersions::V1) | Some(SpecificationVersions::V0) => {
+            v1_content_from_json(data)
+        }
+        Some(_) => Err(DbErr::Custom("Version Not Implemented".to_string())),
+        None => Err(DbErr::Custom("Specification version not found".to_string())),
     }
 }
 
@@ -258,11 +260,19 @@ pub fn to_grouping(groups: Vec<asset_grouping::Model>) -> Vec<Group> {
         .collect()
 }
 
-pub fn get_interface(asset: &asset::Model) -> Interface {
-    Interface::from((
-        &asset.specification_version,
-        &asset.specification_asset_class,
-    ))
+pub fn get_interface(asset: &asset::Model) -> Result<Interface, DbErr> {
+    Ok(Interface::from((
+        asset
+            .specification_version
+            .as_ref()
+            .ok_or(DbErr::Custom("Specification version not found".to_string()))?,
+        asset
+            .specification_asset_class
+            .as_ref()
+            .ok_or(DbErr::Custom(
+                "Specification asset class not found".to_string(),
+            ))?,
+    )))
 }
 
 //TODO -> impl custom erro type
@@ -277,15 +287,15 @@ pub fn asset_to_rpc(asset: FullAsset) -> Result<RpcAsset, DbErr> {
     let rpc_authorities = to_authority(authorities);
     let rpc_creators = to_creators(creators);
     let rpc_groups = to_grouping(groups);
-    let interface = get_interface(&asset);
+    let interface = get_interface(&asset)?;
     let content = get_content(&asset, &data)?;
     let mut chain_data_selector_fn = jsonpath_lib::selector(&data.chain_data);
     let chain_data_selector = &mut chain_data_selector_fn;
     let basis_points = safe_select(chain_data_selector, "$.primary_sale_happened")
         .and_then(|v| v.as_bool())
         .unwrap_or(false);
-    let edition_nonce = safe_select(chain_data_selector, "$.edition_nonce")
-        .and_then(|v| v.as_u64());
+    let edition_nonce =
+        safe_select(chain_data_selector, "$.edition_nonce").and_then(|v| v.as_u64());
 
     Ok(RpcAsset {
         interface: interface.clone(),
@@ -296,8 +306,12 @@ pub fn asset_to_rpc(asset: FullAsset) -> Result<RpcAsset, DbErr> {
         compression: Some(Compression {
             eligible: asset.compressible,
             compressed: asset.compressed,
-            leaf_id: asset.nonce,
-            seq: asset.seq,
+            leaf_id: asset
+                .nonce
+                .ok_or(DbErr::Custom("Nonce not found".to_string()))?,
+            seq: asset
+                .seq
+                .ok_or(DbErr::Custom("Seq not found".to_string()))?,
             tree: asset
                 .tree_id
                 .map(|s| bs58::encode(s).into_string())
@@ -337,7 +351,7 @@ pub fn asset_to_rpc(asset: FullAsset) -> Result<RpcAsset, DbErr> {
         },
         supply: match interface {
             Interface::V1NFT => Some(Supply {
-                edition_nonce: edition_nonce,
+                edition_nonce,
                 print_current_supply: 0,
                 print_max_supply: 0,
             }),