From ea5379e0c4f3d696fb09117d27a722998392c9d8 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Sun, 19 Nov 2023 21:31:02 -0500 Subject: [PATCH 01/21] fmt --- digital_asset_types/src/dao/scopes/asset.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/digital_asset_types/src/dao/scopes/asset.rs b/digital_asset_types/src/dao/scopes/asset.rs index 58e4cbbaf..2df576591 100644 --- a/digital_asset_types/src/dao/scopes/asset.rs +++ b/digital_asset_types/src/dao/scopes/asset.rs @@ -1,10 +1,7 @@ use crate::{ dao::{ - asset::{self}, - asset_authority, asset_creators, asset_data, asset_grouping, cl_audits_v2, - extensions::{self, instruction::PascalCase}, - sea_orm_active_enums::Instruction, - Cursor, FullAsset, GroupingSize, Pagination, + asset, asset_authority, asset_creators, asset_data, asset_grouping, cl_audits_v2, + extensions, Cursor, FullAsset, GroupingSize, Pagination, }, rpc::filter::AssetSortDirection, }; @@ -465,7 +462,8 @@ pub async fn fetch_transactions( .into_iter() .map(|transaction| { let tx = bs58::encode(transaction.tx).into_string(); - let ix = Instruction::to_pascal_case(&transaction.instruction).to_string(); + let ix = extensions::instruction::PascalCase::to_pascal_case(&transaction.instruction) + .to_string(); (tx, ix) }) .collect(); From 8b12316efa6abf242c3853102fbb256c16f524de Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Sun, 19 Nov 2023 22:04:45 -0500 Subject: [PATCH 02/21] clippy --- nft_ingester/src/backfiller.rs | 11 +- .../src/program_transformers/bubblegum/db.rs | 442 ++++++++++++++++++ .../program_transformers/bubblegum/mint_v1.rs | 364 +++++++++++++++ nft_ingester/src/program_transformers/mod.rs | 189 ++++++++ .../src/program_transformers/token/mod.rs | 141 ++++++ .../token_metadata/v1_asset.rs | 393 ++++++++++++++++ 6 files changed, 1532 insertions(+), 8 deletions(-) create mode 100644 nft_ingester/src/program_transformers/bubblegum/db.rs create mode 100644 nft_ingester/src/program_transformers/bubblegum/mint_v1.rs create mode 100644 nft_ingester/src/program_transformers/mod.rs create mode 100644 nft_ingester/src/program_transformers/token/mod.rs create mode 100644 nft_ingester/src/program_transformers/token_metadata/v1_asset.rs diff --git a/nft_ingester/src/backfiller.rs b/nft_ingester/src/backfiller.rs index fd7d3e19c..fcf27fad3 100644 --- a/nft_ingester/src/backfiller.rs +++ b/nft_ingester/src/backfiller.rs @@ -628,14 +628,9 @@ impl<'a, T: Messenger> Backfiller<'a, T> { &mut self, btree: &BackfillTree, ) -> Result, IngesterError> { - let address = match Pubkey::try_from(btree.unique_tree.tree.as_slice()) { - Ok(pubkey) => pubkey, - Err(error) => { - return Err(IngesterError::DeserializationError(format!( - "failed to parse pubkey: {error:?}" - ))) - } - }; + let address = Pubkey::try_from(btree.unique_tree.tree.as_slice()).map_err(|error| { + IngesterError::DeserializationError(format!("failed to parse pubkey: {error:?}")) + })?; let slots = self.find_slots_via_address(&address).await?; let address = btree.unique_tree.tree.clone(); diff --git a/nft_ingester/src/program_transformers/bubblegum/db.rs b/nft_ingester/src/program_transformers/bubblegum/db.rs new file mode 100644 index 000000000..c562be2be --- /dev/null +++ b/nft_ingester/src/program_transformers/bubblegum/db.rs @@ -0,0 +1,442 @@ +use crate::error::IngesterError; +use digital_asset_types::dao::{ + asset, asset_creators, asset_grouping, backfill_items, cl_audits, cl_items, +}; +use log::{debug, info}; +use mpl_bubblegum::types::Collection; +use sea_orm::{ + query::*, sea_query::OnConflict, ActiveValue::Set, ColumnTrait, DbBackend, EntityTrait, +}; +use spl_account_compression::events::ChangeLogEventV1; + +pub async fn save_changelog_event<'c, T>( + change_log_event: &ChangeLogEventV1, + slot: u64, + txn_id: &str, + txn: &T, + cl_audits: bool, +) -> Result +where + T: ConnectionTrait + TransactionTrait, +{ + insert_change_log(change_log_event, slot, txn_id, txn, cl_audits).await?; + Ok(change_log_event.seq) +} + +fn node_idx_to_leaf_idx(index: i64, tree_height: u32) -> i64 { + index - 2i64.pow(tree_height) +} + +pub async fn insert_change_log<'c, T>( + change_log_event: &ChangeLogEventV1, + slot: u64, + txn_id: &str, + txn: &T, + cl_audits: bool, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let mut i: i64 = 0; + let depth = change_log_event.path.len() - 1; + let tree_id = change_log_event.id.as_ref(); + for p in change_log_event.path.iter() { + let node_idx = p.index as i64; + debug!( + "seq {}, index {} level {}, node {:?}, txn: {:?}", + change_log_event.seq, + p.index, + i, + bs58::encode(p.node).into_string(), + txn_id, + ); + let leaf_idx = if i == 0 { + Some(node_idx_to_leaf_idx(node_idx, depth as u32)) + } else { + None + }; + + let item = cl_items::ActiveModel { + tree: Set(tree_id.to_vec()), + level: Set(i), + node_idx: Set(node_idx), + hash: Set(p.node.as_ref().to_vec()), + seq: Set(change_log_event.seq as i64), + leaf_idx: Set(leaf_idx), + ..Default::default() + }; + + let audit_item: Option = if cl_audits { + let mut ai: cl_audits::ActiveModel = item.clone().into(); + ai.tx = Set(txn_id.to_string()); + Some(ai) + } else { + None + }; + + i += 1; + let mut query = cl_items::Entity::insert(item) + .on_conflict( + OnConflict::columns([cl_items::Column::Tree, cl_items::Column::NodeIdx]) + .update_columns([ + cl_items::Column::Hash, + cl_items::Column::Seq, + cl_items::Column::LeafIdx, + cl_items::Column::Level, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!("{} WHERE excluded.seq > cl_items.seq", query.sql); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + // Insert the audit item after the insert into cl_items have been completed + if let Some(audit_item) = audit_item { + cl_audits::Entity::insert(audit_item).exec(txn).await?; + } + } + + // If and only if the entire path of nodes was inserted into the `cl_items` table, then insert + // a single row into the `backfill_items` table. This way if an incomplete path was inserted + // into `cl_items` due to an error, a gap will be created for the tree and the backfiller will + // fix it. + if i - 1 == depth as i64 { + // See if the tree already exists in the `backfill_items` table. + let rows = backfill_items::Entity::find() + .filter(backfill_items::Column::Tree.eq(tree_id)) + .limit(1) + .all(txn) + .await?; + + // If the tree does not exist in `backfill_items` and the sequence number is greater than 1, + // then we know we will need to backfill the tree from sequence number 1 up to the current + // sequence number. So in this case we set at flag to force checking the tree. + let force_chk = rows.is_empty() && change_log_event.seq > 1; + + info!("Adding to backfill_items table at level {}", i - 1); + let item = backfill_items::ActiveModel { + tree: Set(tree_id.to_vec()), + seq: Set(change_log_event.seq as i64), + slot: Set(slot as i64), + force_chk: Set(force_chk), + backfilled: Set(false), + failed: Set(false), + ..Default::default() + }; + + backfill_items::Entity::insert(item).exec(txn).await?; + } + + Ok(()) + //TODO -> set maximum size of path and break into multiple statements +} + +#[allow(clippy::too_many_arguments)] +pub async fn upsert_asset_with_leaf_info( + txn: &T, + id: Vec, + nonce: i64, + tree_id: Vec, + leaf: Vec, + data_hash: [u8; 32], + creator_hash: [u8; 32], + seq: i64, + was_decompressed: bool, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let data_hash = bs58::encode(data_hash).into_string().trim().to_string(); + let creator_hash = bs58::encode(creator_hash).into_string().trim().to_string(); + let model = asset::ActiveModel { + id: Set(id), + nonce: Set(Some(nonce)), + tree_id: Set(Some(tree_id)), + leaf: Set(Some(leaf)), + data_hash: Set(Some(data_hash)), + creator_hash: Set(Some(creator_hash)), + leaf_seq: Set(Some(seq)), + ..Default::default() + }; + + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::column(asset::Column::Id) + .update_columns([ + asset::Column::Nonce, + asset::Column::TreeId, + asset::Column::Leaf, + asset::Column::LeafSeq, + asset::Column::DataHash, + asset::Column::CreatorHash, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + + // If we are indexing decompression we will update the leaf regardless of if we have previously + // indexed decompression and regardless of seq. + if !was_decompressed { + query.sql = format!( + "{} WHERE (NOT asset.was_decompressed) AND (excluded.leaf_seq >= asset.leaf_seq OR asset.leaf_seq IS NULL)", + query.sql + ); + } + + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} + +pub async fn upsert_asset_with_leaf_info_for_decompression( + txn: &T, + id: Vec, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let model = asset::ActiveModel { + id: Set(id), + leaf: Set(None), + nonce: Set(Some(0)), + leaf_seq: Set(None), + data_hash: Set(None), + creator_hash: Set(None), + tree_id: Set(None), + seq: Set(Some(0)), + ..Default::default() + }; + let query = asset::Entity::insert(model) + .on_conflict( + OnConflict::column(asset::Column::Id) + .update_columns([ + asset::Column::Leaf, + asset::Column::LeafSeq, + asset::Column::Nonce, + asset::Column::DataHash, + asset::Column::CreatorHash, + asset::Column::TreeId, + asset::Column::Seq, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} + +pub async fn upsert_asset_with_owner_and_delegate_info( + txn: &T, + id: Vec, + owner: Vec, + delegate: Option>, + seq: i64, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let model = asset::ActiveModel { + id: Set(id), + owner: Set(Some(owner)), + delegate: Set(delegate), + owner_delegate_seq: Set(Some(seq)), // gummyroll seq + ..Default::default() + }; + + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::column(asset::Column::Id) + .update_columns([ + asset::Column::Owner, + asset::Column::Delegate, + asset::Column::OwnerDelegateSeq, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.owner_delegate_seq >= asset.owner_delegate_seq OR asset.owner_delegate_seq IS NULL", + query.sql + ); + + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} + +pub async fn upsert_asset_with_compression_info( + txn: &T, + id: Vec, + compressed: bool, + compressible: bool, + supply: i64, + supply_mint: Option>, + was_decompressed: bool, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let model = asset::ActiveModel { + id: Set(id), + compressed: Set(compressed), + compressible: Set(compressible), + supply: Set(supply), + supply_mint: Set(supply_mint), + was_decompressed: Set(was_decompressed), + ..Default::default() + }; + + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::columns([asset::Column::Id]) + .update_columns([ + asset::Column::Compressed, + asset::Column::Compressible, + asset::Column::Supply, + asset::Column::SupplyMint, + asset::Column::WasDecompressed, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!("{} WHERE NOT asset.was_decompressed", query.sql); + txn.execute(query).await?; + + Ok(()) +} + +pub async fn upsert_asset_with_seq(txn: &T, id: Vec, seq: i64) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let model = asset::ActiveModel { + id: Set(id), + seq: Set(Some(seq)), + ..Default::default() + }; + + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::column(asset::Column::Id) + .update_columns([asset::Column::Seq]) + .to_owned(), + ) + .build(DbBackend::Postgres); + + query.sql = format!( + "{} WHERE (NOT asset.was_decompressed) AND (excluded.seq >= asset.seq OR asset.seq IS NULL)", + query.sql + ); + + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} + +pub async fn upsert_creator_verified( + txn: &T, + asset_id: Vec, + creator: Vec, + verified: bool, + seq: i64, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let model = asset_creators::ActiveModel { + asset_id: Set(asset_id), + creator: Set(creator), + verified: Set(verified), + seq: Set(Some(seq)), + ..Default::default() + }; + + let mut query = asset_creators::Entity::insert(model) + .on_conflict( + OnConflict::columns([ + asset_creators::Column::AssetId, + asset_creators::Column::Creator, + ]) + .update_columns([ + asset_creators::Column::Verified, + asset_creators::Column::Seq, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + + query.sql = format!( + "{} WHERE excluded.seq >= asset_creators.seq OR asset_creators.seq is NULL", + query.sql + ); + + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} + +pub async fn upsert_collection_info( + txn: &T, + asset_id: Vec, + collection: Option, + slot_updated: i64, + seq: i64, +) -> Result<(), IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + let (group_value, verified) = match collection { + Some(c) => (Some(c.key.to_string()), c.verified), + None => (None, false), + }; + + let model = asset_grouping::ActiveModel { + asset_id: Set(asset_id), + group_key: Set("collection".to_string()), + group_value: Set(group_value), + verified: Set(Some(verified)), + slot_updated: Set(Some(slot_updated)), + group_info_seq: Set(Some(seq)), + ..Default::default() + }; + + let mut query = asset_grouping::Entity::insert(model) + .on_conflict( + OnConflict::columns([ + asset_grouping::Column::AssetId, + asset_grouping::Column::GroupKey, + ]) + .update_columns([ + asset_grouping::Column::GroupValue, + asset_grouping::Column::Verified, + asset_grouping::Column::SlotUpdated, + asset_grouping::Column::GroupInfoSeq, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + + query.sql = format!( + "{} WHERE excluded.group_info_seq >= asset_grouping.group_info_seq OR asset_grouping.group_info_seq IS NULL", + query.sql + ); + + txn.execute(query) + .await + .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; + + Ok(()) +} diff --git a/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs b/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs new file mode 100644 index 000000000..685649f79 --- /dev/null +++ b/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs @@ -0,0 +1,364 @@ +use crate::{ + error::IngesterError, + program_transformers::bubblegum::{ + save_changelog_event, upsert_asset_with_compression_info, upsert_asset_with_leaf_info, + upsert_asset_with_owner_and_delegate_info, upsert_asset_with_seq, upsert_collection_info, + }, + tasks::{DownloadMetadata, IntoTaskData, TaskData}, +}; +use blockbuster::{ + instruction::InstructionBundle, + programs::bubblegum::{BubblegumInstruction, LeafSchema, Payload}, + token_metadata::{ + pda::find_master_edition_account, + state::{TokenStandard, UseMethod, Uses}, + }, +}; +use chrono::Utc; +use digital_asset_types::{ + dao::{ + asset, asset_authority, asset_creators, asset_data, asset_v1_account_attachments, + sea_orm_active_enums::{ChainMutability, Mutability, OwnerType, RoyaltyTargetType}, + }, + json::ChainDataV1, +}; +use log::warn; +use num_traits::FromPrimitive; +use sea_orm::{ + entity::*, query::*, sea_query::OnConflict, ConnectionTrait, DbBackend, EntityTrait, JsonValue, +}; +use std::collections::HashSet; + +use digital_asset_types::dao::sea_orm_active_enums::{ + SpecificationAssetClass, SpecificationVersions, V1AccountAttachments, +}; + +// TODO -> consider moving structs into these functions to avoid clone + +pub async fn mint_v1<'c, T>( + parsing_result: &BubblegumInstruction, + bundle: &InstructionBundle<'c>, + txn: &'c T, + cl_audits: bool, +) -> Result, IngesterError> +where + T: ConnectionTrait + TransactionTrait, +{ + if let (Some(le), Some(cl), Some(Payload::MintV1 { args })) = ( + &parsing_result.leaf_update, + &parsing_result.tree_update, + &parsing_result.payload, + ) { + let seq = save_changelog_event(cl, bundle.slot, bundle.txn_id, txn, cl_audits).await?; + let metadata = args; + #[allow(unreachable_patterns)] + return match le.schema { + LeafSchema::V1 { + id, + delegate, + owner, + nonce, + .. + } => { + let (edition_attachment_address, _) = find_master_edition_account(&id); + let id_bytes = id.to_bytes(); + let slot_i = bundle.slot as i64; + let uri = metadata.uri.replace('\0', ""); + let name = metadata.name.clone().into_bytes(); + let symbol = metadata.symbol.clone().into_bytes(); + let mut chain_data = ChainDataV1 { + name: metadata.name.clone(), + symbol: metadata.symbol.clone(), + edition_nonce: metadata.edition_nonce, + primary_sale_happened: metadata.primary_sale_happened, + token_standard: Some(TokenStandard::NonFungible), + uses: metadata.uses.clone().map(|u| Uses { + use_method: UseMethod::from_u8(u.use_method as u8).unwrap(), + remaining: u.remaining, + total: u.total, + }), + }; + chain_data.sanitize(); + let chain_data_json = serde_json::to_value(chain_data) + .map_err(|e| IngesterError::DeserializationError(e.to_string()))?; + let chain_mutability = match metadata.is_mutable { + true => ChainMutability::Mutable, + false => ChainMutability::Immutable, + }; + + let data = asset_data::ActiveModel { + id: Set(id_bytes.to_vec()), + chain_data_mutability: Set(chain_mutability), + chain_data: Set(chain_data_json), + metadata_url: Set(uri.clone()), + metadata: Set(JsonValue::String("processing".to_string())), + metadata_mutability: Set(Mutability::Mutable), + slot_updated: Set(slot_i), + reindex: Set(Some(true)), + raw_name: Set(name.to_vec()), + raw_symbol: Set(symbol.to_vec()), + }; + + let mut query = asset_data::Entity::insert(data) + .on_conflict( + OnConflict::columns([asset_data::Column::Id]) + .update_columns([ + asset_data::Column::ChainDataMutability, + asset_data::Column::ChainData, + asset_data::Column::MetadataUrl, + asset_data::Column::MetadataMutability, + asset_data::Column::SlotUpdated, + asset_data::Column::Reindex, + asset_data::Column::RawName, + asset_data::Column::RawSymbol, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset_data.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + // Insert into `asset` table. + let delegate = if owner == delegate || delegate.to_bytes() == [0; 32] { + None + } else { + Some(delegate.to_bytes().to_vec()) + }; + let tree_id = bundle.keys.get(3).unwrap().0.to_vec(); + + // Set initial mint info. + let asset_model = asset::ActiveModel { + id: Set(id_bytes.to_vec()), + owner_type: Set(OwnerType::Single), + frozen: Set(false), + tree_id: Set(Some(tree_id.clone())), + specification_version: Set(Some(SpecificationVersions::V1)), + specification_asset_class: Set(Some(SpecificationAssetClass::Nft)), + nonce: Set(Some(nonce as i64)), + royalty_target_type: Set(RoyaltyTargetType::Creators), + royalty_target: Set(None), + royalty_amount: Set(metadata.seller_fee_basis_points as i32), //basis points + asset_data: Set(Some(id_bytes.to_vec())), + slot_updated: Set(Some(slot_i)), + ..Default::default() + }; + + // Upsert asset table base info. + let mut query = asset::Entity::insert(asset_model) + .on_conflict( + OnConflict::columns([asset::Column::Id]) + .update_columns([ + asset::Column::OwnerType, + asset::Column::Frozen, + asset::Column::SpecificationVersion, + asset::Column::SpecificationAssetClass, + asset::Column::RoyaltyTargetType, + asset::Column::RoyaltyTarget, + asset::Column::RoyaltyAmount, + asset::Column::AssetData, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + + // Do not overwrite changes that happened after the asset was decompressed. + query.sql = format!( + "{} WHERE excluded.slot_updated > asset.slot_updated OR asset.slot_updated IS NULL", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + + // Partial update of asset table with just compression info elements. + upsert_asset_with_compression_info( + txn, + id_bytes.to_vec(), + true, + false, + 1, + None, + false, + ) + .await?; + + // Partial update of asset table with just leaf. + upsert_asset_with_leaf_info( + txn, + id_bytes.to_vec(), + nonce as i64, + tree_id, + le.leaf_hash.to_vec(), + le.schema.data_hash(), + le.schema.creator_hash(), + seq as i64, + false, + ) + .await?; + + // Partial update of asset table with just leaf owner and delegate. + upsert_asset_with_owner_and_delegate_info( + txn, + id_bytes.to_vec(), + owner.to_bytes().to_vec(), + delegate, + seq as i64, + ) + .await?; + + upsert_asset_with_seq(txn, id_bytes.to_vec(), seq as i64).await?; + + let attachment = asset_v1_account_attachments::ActiveModel { + id: Set(edition_attachment_address.to_bytes().to_vec()), + slot_updated: Set(slot_i), + attachment_type: Set(V1AccountAttachments::MasterEditionV2), + ..Default::default() + }; + + let query = asset_v1_account_attachments::Entity::insert(attachment) + .on_conflict( + OnConflict::columns([asset_v1_account_attachments::Column::Id]) + .do_nothing() + .to_owned(), + ) + .build(DbBackend::Postgres); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + + // Insert into `asset_creators` table. + let creators = &metadata.creators; + if !creators.is_empty() { + // Vec to hold base creator information. + let mut db_creator_infos = Vec::with_capacity(creators.len()); + + // Vec to hold info on whether a creator is verified. This info is protected by `seq` number. + let mut db_creator_verified_infos = Vec::with_capacity(creators.len()); + + // Set to prevent duplicates. + let mut creators_set = HashSet::new(); + + for (i, c) in creators.iter().enumerate() { + if creators_set.contains(&c.address) { + continue; + } + db_creator_infos.push(asset_creators::ActiveModel { + asset_id: Set(id_bytes.to_vec()), + creator: Set(c.address.to_bytes().to_vec()), + position: Set(i as i16), + share: Set(c.share as i32), + slot_updated: Set(Some(slot_i)), + ..Default::default() + }); + + db_creator_verified_infos.push(asset_creators::ActiveModel { + asset_id: Set(id_bytes.to_vec()), + creator: Set(c.address.to_bytes().to_vec()), + verified: Set(c.verified), + seq: Set(Some(seq as i64)), + ..Default::default() + }); + + creators_set.insert(c.address); + } + + // This statement will update base information for each creator. + let query = asset_creators::Entity::insert_many(db_creator_infos) + .on_conflict( + OnConflict::columns([ + asset_creators::Column::AssetId, + asset_creators::Column::Creator, + ]) + .update_columns([ + asset_creators::Column::Position, + asset_creators::Column::Share, + asset_creators::Column::SlotUpdated, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + txn.execute(query).await?; + + // This statement will update whether the creator is verified and the `seq` + // number. `seq` is used to protect the `verified` field, allowing for `mint` + // and `verifyCreator` to be processed out of order. + let mut query = asset_creators::Entity::insert_many(db_creator_verified_infos) + .on_conflict( + OnConflict::columns([ + asset_creators::Column::AssetId, + asset_creators::Column::Creator, + ]) + .update_columns([ + asset_creators::Column::Verified, + asset_creators::Column::Seq, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.seq > asset_creators.seq OR asset_creators.seq IS NULL", + query.sql + ); + txn.execute(query).await?; + } + + // Insert into `asset_authority` table. + let model = asset_authority::ActiveModel { + asset_id: Set(id_bytes.to_vec()), + authority: Set(bundle.keys.get(0).unwrap().0.to_vec()), //TODO - we need to rem,ove the optional bubblegum signer logic + seq: Set(seq as i64), + slot_updated: Set(slot_i), + ..Default::default() + }; + + // Do not attempt to modify any existing values: + // `ON CONFLICT ('asset_id') DO NOTHING`. + let query = asset_authority::Entity::insert(model) + .on_conflict( + OnConflict::columns([asset_authority::Column::AssetId]) + .do_nothing() + .to_owned(), + ) + .build(DbBackend::Postgres); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + + // Upsert into `asset_grouping` table with base collection info. + upsert_collection_info( + txn, + id_bytes.to_vec(), + metadata.collection.clone(), + slot_i, + seq as i64, + ) + .await?; + + if uri.is_empty() { + warn!( + "URI is empty for mint {}. Skipping background task.", + bs58::encode(id).into_string() + ); + return Ok(None); + } + + let mut task = DownloadMetadata { + asset_data_id: id_bytes.to_vec(), + uri: metadata.uri.clone(), + created_at: Some(Utc::now().naive_utc()), + }; + task.sanitize(); + let t = task.into_task_data()?; + Ok(Some(t)) + } + _ => Err(IngesterError::NotImplemented), + }; + } + Err(IngesterError::ParsingError( + "Ix not parsed correctly".to_string(), + )) +} diff --git a/nft_ingester/src/program_transformers/mod.rs b/nft_ingester/src/program_transformers/mod.rs new file mode 100644 index 000000000..fc555829d --- /dev/null +++ b/nft_ingester/src/program_transformers/mod.rs @@ -0,0 +1,189 @@ +use crate::{error::IngesterError, tasks::TaskData}; +use blockbuster::{ + instruction::{order_instructions, InstructionBundle, IxPair}, + program_handler::ProgramParser, + programs::{ + bubblegum::BubblegumParser, token_account::TokenAccountParser, + token_metadata::TokenMetadataParser, ProgramParseResult, + }, +}; +use log::{debug, error, info}; +use plerkle_serialization::{AccountInfo, Pubkey as FBPubkey, TransactionInfo}; +use sea_orm::{DatabaseConnection, SqlxPostgresConnector}; +use solana_sdk::pubkey::Pubkey; +use sqlx::PgPool; +use std::collections::{HashMap, HashSet, VecDeque}; +use tokio::sync::mpsc::UnboundedSender; + +use crate::program_transformers::{ + bubblegum::handle_bubblegum_instruction, token::handle_token_program_account, + token_metadata::handle_token_metadata_account, +}; + +mod bubblegum; +mod token; +mod token_metadata; + +pub struct ProgramTransformer { + storage: DatabaseConnection, + task_sender: UnboundedSender, + matchers: HashMap>, + key_set: HashSet, + cl_audits: bool, +} + +impl ProgramTransformer { + pub fn new(pool: PgPool, task_sender: UnboundedSender, cl_audits: bool) -> Self { + let mut matchers: HashMap> = HashMap::with_capacity(1); + let bgum = BubblegumParser {}; + let token_metadata = TokenMetadataParser {}; + let token = TokenAccountParser {}; + matchers.insert(bgum.key(), Box::new(bgum)); + matchers.insert(token_metadata.key(), Box::new(token_metadata)); + matchers.insert(token.key(), Box::new(token)); + let hs = matchers.iter().fold(HashSet::new(), |mut acc, (k, _)| { + acc.insert(*k); + acc + }); + let pool: PgPool = pool; + ProgramTransformer { + storage: SqlxPostgresConnector::from_sqlx_postgres_pool(pool), + task_sender, + matchers, + key_set: hs, + cl_audits, + } + } + + pub fn break_transaction<'i>( + &self, + tx: &'i TransactionInfo<'i>, + ) -> VecDeque<(IxPair<'i>, Option>>)> { + let ref_set: HashSet<&[u8]> = self.key_set.iter().map(|k| k.as_ref()).collect(); + order_instructions(ref_set, tx) + } + + #[allow(clippy::borrowed_box)] + pub fn match_program(&self, key: &FBPubkey) -> Option<&Box> { + self.matchers + .get(&Pubkey::try_from(key.0.as_slice()).expect("valid key from FlatBuffer")) + } + + pub async fn handle_transaction<'a>( + &self, + tx: &'a TransactionInfo<'a>, + ) -> Result<(), IngesterError> { + let sig: Option<&str> = tx.signature(); + info!("Handling Transaction: {:?}", sig); + let instructions = self.break_transaction(tx); + let accounts = tx.account_keys().unwrap_or_default(); + let slot = tx.slot(); + let txn_id = tx.signature().unwrap_or(""); + let mut keys: Vec = Vec::with_capacity(accounts.len()); + for k in accounts.into_iter() { + keys.push(*k); + } + let mut not_impl = 0; + let ixlen = instructions.len(); + debug!("Instructions: {}", ixlen); + let contains = instructions + .iter() + .filter(|(ib, _inner)| ib.0 .0.as_ref() == mpl_bubblegum::ID.as_ref()); + debug!("Instructions bgum: {}", contains.count()); + for (outer_ix, inner_ix) in instructions { + let (program, instruction) = outer_ix; + let ix_accounts = instruction.accounts().unwrap().iter().collect::>(); + let ix_account_len = ix_accounts.len(); + let max = ix_accounts.iter().max().copied().unwrap_or(0) as usize; + if keys.len() < max { + return Err(IngesterError::DeserializationError( + "Missing Accounts in Serialized Ixn/Txn".to_string(), + )); + } + let ix_accounts = + ix_accounts + .iter() + .fold(Vec::with_capacity(ix_account_len), |mut acc, a| { + if let Some(key) = keys.get(*a as usize) { + acc.push(*key); + } + acc + }); + let ix = InstructionBundle { + txn_id, + program, + instruction: Some(instruction), + inner_ix, + keys: ix_accounts.as_slice(), + slot, + }; + + if let Some(program) = self.match_program(&ix.program) { + debug!("Found a ix for program: {:?}", program.key()); + let result = program.handle_instruction(&ix)?; + let concrete = result.result_type(); + match concrete { + ProgramParseResult::Bubblegum(parsing_result) => { + handle_bubblegum_instruction( + parsing_result, + &ix, + &self.storage, + &self.task_sender, + self.cl_audits, + ) + .await + .map_err(|err| { + error!( + "Failed to handle bubblegum instruction for txn {:?}: {:?}", + sig, err + ); + err + })?; + } + _ => { + not_impl += 1; + } + }; + } + } + + if not_impl == ixlen { + debug!("Not imple"); + return Err(IngesterError::NotImplemented); + } + Ok(()) + } + + pub async fn handle_account_update<'b>( + &self, + acct: AccountInfo<'b>, + ) -> Result<(), IngesterError> { + let owner = acct.owner().unwrap(); + if let Some(program) = self.match_program(owner) { + let result = program.handle_account(&acct)?; + let concrete = result.result_type(); + match concrete { + ProgramParseResult::TokenMetadata(parsing_result) => { + handle_token_metadata_account( + &acct, + parsing_result, + &self.storage, + &self.task_sender, + ) + .await + } + ProgramParseResult::TokenProgramAccount(parsing_result) => { + handle_token_program_account( + &acct, + parsing_result, + &self.storage, + &self.task_sender, + ) + .await + } + _ => Err(IngesterError::NotImplemented), + }?; + } + Ok(()) + } +} diff --git a/nft_ingester/src/program_transformers/token/mod.rs b/nft_ingester/src/program_transformers/token/mod.rs new file mode 100644 index 000000000..c32cad020 --- /dev/null +++ b/nft_ingester/src/program_transformers/token/mod.rs @@ -0,0 +1,141 @@ +use crate::{error::IngesterError, tasks::TaskData}; +use blockbuster::programs::token_account::TokenProgramAccount; +use digital_asset_types::dao::{asset, token_accounts, tokens}; +use plerkle_serialization::AccountInfo; +use sea_orm::{ + entity::*, query::*, sea_query::OnConflict, ActiveValue::Set, ConnectionTrait, + DatabaseConnection, DbBackend, EntityTrait, +}; +use solana_sdk::program_option::COption; +use spl_token::state::AccountState; +use tokio::sync::mpsc::UnboundedSender; + +pub async fn handle_token_program_account<'a, 'b, 'c>( + account_update: &'a AccountInfo<'a>, + parsing_result: &'b TokenProgramAccount, + db: &'c DatabaseConnection, + _task_manager: &UnboundedSender, +) -> Result<(), IngesterError> { + let key = *account_update.pubkey().unwrap(); + let key_bytes = key.0.to_vec(); + let spl_token_program = account_update.owner().unwrap().0.to_vec(); + match &parsing_result { + TokenProgramAccount::TokenAccount(ta) => { + let mint = ta.mint.to_bytes().to_vec(); + let delegate: Option> = match ta.delegate { + COption::Some(d) => Some(d.to_bytes().to_vec()), + COption::None => None, + }; + let frozen = matches!(ta.state, AccountState::Frozen); + let owner = ta.owner.to_bytes().to_vec(); + let model = token_accounts::ActiveModel { + pubkey: Set(key_bytes), + mint: Set(mint.clone()), + delegate: Set(delegate.clone()), + owner: Set(owner.clone()), + frozen: Set(frozen), + delegated_amount: Set(ta.delegated_amount as i64), + token_program: Set(spl_token_program), + slot_updated: Set(account_update.slot() as i64), + amount: Set(ta.amount as i64), + close_authority: Set(None), + }; + + let mut query = token_accounts::Entity::insert(model) + .on_conflict( + OnConflict::columns([token_accounts::Column::Pubkey]) + .update_columns([ + token_accounts::Column::Mint, + token_accounts::Column::DelegatedAmount, + token_accounts::Column::Delegate, + token_accounts::Column::Amount, + token_accounts::Column::Frozen, + token_accounts::Column::TokenProgram, + token_accounts::Column::Owner, + token_accounts::Column::CloseAuthority, + token_accounts::Column::SlotUpdated, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > token_accounts.slot_updated", + query.sql + ); + db.execute(query).await?; + let txn = db.begin().await?; + let asset_update: Option = asset::Entity::find_by_id(mint) + .filter(asset::Column::OwnerType.eq("single")) + .one(&txn) + .await?; + if let Some(asset) = asset_update { + // will only update owner if token account balance is non-zero + if ta.amount > 0 { + let mut active: asset::ActiveModel = asset.into(); + active.owner = Set(Some(owner)); + active.delegate = Set(delegate); + active.frozen = Set(frozen); + active.save(&txn).await?; + } + } + txn.commit().await?; + Ok(()) + } + TokenProgramAccount::Mint(m) => { + let freeze_auth: Option> = match m.freeze_authority { + COption::Some(d) => Some(d.to_bytes().to_vec()), + COption::None => None, + }; + let mint_auth: Option> = match m.mint_authority { + COption::Some(d) => Some(d.to_bytes().to_vec()), + COption::None => None, + }; + let model = tokens::ActiveModel { + mint: Set(key_bytes.clone()), + token_program: Set(spl_token_program), + slot_updated: Set(account_update.slot() as i64), + supply: Set(m.supply as i64), + decimals: Set(m.decimals as i32), + close_authority: Set(None), + extension_data: Set(None), + mint_authority: Set(mint_auth), + freeze_authority: Set(freeze_auth), + }; + + let mut query = tokens::Entity::insert(model) + .on_conflict( + OnConflict::columns([tokens::Column::Mint]) + .update_columns([ + tokens::Column::Supply, + tokens::Column::TokenProgram, + tokens::Column::MintAuthority, + tokens::Column::CloseAuthority, + tokens::Column::ExtensionData, + tokens::Column::SlotUpdated, + tokens::Column::Decimals, + tokens::Column::FreezeAuthority, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > tokens.slot_updated", + query.sql + ); + db.execute(query).await?; + let asset_update: Option = asset::Entity::find_by_id(key_bytes.clone()) + .filter(asset::Column::OwnerType.eq("single")) + .one(db) + .await?; + if let Some(asset) = asset_update { + let mut active: asset::ActiveModel = asset.into(); + active.supply = Set(m.supply as i64); + active.supply_mint = Set(Some(key_bytes)); + active.save(db).await?; + } + Ok(()) + } + _ => Err(IngesterError::NotImplemented), + }?; + Ok(()) +} diff --git a/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs b/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs new file mode 100644 index 000000000..4f81a4636 --- /dev/null +++ b/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs @@ -0,0 +1,393 @@ +use crate::{error::IngesterError, tasks::TaskData}; +use blockbuster::token_metadata::{ + pda::find_master_edition_account, + state::{Metadata, TokenStandard, UseMethod, Uses}, +}; +use chrono::Utc; +use digital_asset_types::{ + dao::{ + asset, asset_authority, asset_creators, asset_data, asset_grouping, + asset_v1_account_attachments, + sea_orm_active_enums::{ + ChainMutability, Mutability, OwnerType, RoyaltyTargetType, SpecificationAssetClass, + SpecificationVersions, V1AccountAttachments, + }, + token_accounts, tokens, + }, + json::ChainDataV1, +}; + +use crate::tasks::{DownloadMetadata, IntoTaskData}; +use log::warn; +use num_traits::FromPrimitive; +use plerkle_serialization::Pubkey as FBPubkey; +use sea_orm::{ + entity::*, query::*, sea_query::OnConflict, ActiveValue::Set, ConnectionTrait, DbBackend, + DbErr, EntityTrait, JsonValue, +}; +use std::collections::HashSet; + +pub async fn burn_v1_asset( + conn: &T, + id: FBPubkey, + slot: u64, +) -> Result<(), IngesterError> { + let (id, slot_i) = (id.0, slot as i64); + let model = asset::ActiveModel { + id: Set(id.to_vec()), + slot_updated: Set(Some(slot_i)), + burnt: Set(true), + ..Default::default() + }; + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::columns([asset::Column::Id]) + .update_columns([asset::Column::SlotUpdated, asset::Column::Burnt]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset.slot_updated", + query.sql + ); + conn.execute(query).await?; + Ok(()) +} + +pub async fn save_v1_asset( + conn: &T, + id: FBPubkey, + slot: u64, + metadata: &Metadata, +) -> Result, IngesterError> { + let metadata = metadata.clone(); + let data = metadata.data; + let meta_mint_pubkey = metadata.mint; + let (edition_attachment_address, _) = find_master_edition_account(&meta_mint_pubkey); + let mint = metadata.mint.to_bytes().to_vec(); + let authority = metadata.update_authority.to_bytes().to_vec(); + let id = id.0; + let slot_i = slot as i64; + let uri = data.uri.trim().replace('\0', ""); + let _spec = SpecificationVersions::V1; + let class = match metadata.token_standard { + Some(TokenStandard::NonFungible) => SpecificationAssetClass::Nft, + Some(TokenStandard::FungibleAsset) => SpecificationAssetClass::FungibleAsset, + Some(TokenStandard::Fungible) => SpecificationAssetClass::FungibleToken, + _ => SpecificationAssetClass::Unknown, + }; + let ownership_type = match class { + SpecificationAssetClass::FungibleAsset => OwnerType::Token, + SpecificationAssetClass::FungibleToken => OwnerType::Token, + _ => OwnerType::Single, + }; + + // gets the token and token account for the mint to populate the asset. This is required when the token and token account are indexed, but not the metadata account. If the metadata account is indexed, then the token and ta ingester will update the asset with the correct data + + let (token, token_account): (Option, Option) = + match ownership_type { + OwnerType::Single => { + let token: Option = + tokens::Entity::find_by_id(mint.clone()).one(conn).await?; + // query for token account associated with mint with positive balance + let token_account: Option = token_accounts::Entity::find() + .filter(token_accounts::Column::Mint.eq(mint.clone())) + .filter(token_accounts::Column::Amount.gt(0)) + .one(conn) + .await?; + Ok((token, token_account)) + } + _ => { + let token = tokens::Entity::find_by_id(mint.clone()).one(conn).await?; + Ok((token, None)) + } + } + .map_err(|e: DbErr| IngesterError::DatabaseError(e.to_string()))?; + + // get supply of token, default to 1 since most cases will be NFTs. Token mint ingester will properly set supply if token_result is None + let (supply, supply_mint) = match token { + Some(t) => (Set(t.supply), Set(Some(t.mint))), + None => (Set(1), NotSet), + }; + + // owner and delegate should be from the token account with the mint + let (owner, delegate) = match token_account { + Some(ta) => (Set(Some(ta.owner)), Set(ta.delegate)), + None => (NotSet, NotSet), + }; + + let name = data.name.clone().into_bytes(); + let symbol = data.symbol.clone().into_bytes(); + + let mut chain_data = ChainDataV1 { + name: data.name.clone(), + symbol: data.symbol.clone(), + edition_nonce: metadata.edition_nonce, + primary_sale_happened: metadata.primary_sale_happened, + token_standard: metadata.token_standard, + uses: metadata.uses.map(|u| Uses { + use_method: UseMethod::from_u8(u.use_method as u8).unwrap(), + remaining: u.remaining, + total: u.total, + }), + }; + chain_data.sanitize(); + let chain_data_json = serde_json::to_value(chain_data) + .map_err(|e| IngesterError::DeserializationError(e.to_string()))?; + let chain_mutability = match metadata.is_mutable { + true => ChainMutability::Mutable, + false => ChainMutability::Immutable, + }; + let asset_data_model = asset_data::ActiveModel { + chain_data_mutability: Set(chain_mutability), + chain_data: Set(chain_data_json), + metadata_url: Set(uri.clone()), + metadata: Set(JsonValue::String("processing".to_string())), + metadata_mutability: Set(Mutability::Mutable), + slot_updated: Set(slot_i), + reindex: Set(Some(true)), + id: Set(id.to_vec()), + raw_name: Set(name.to_vec()), + raw_symbol: Set(symbol.to_vec()), + }; + let txn = conn.begin().await?; + let mut query = asset_data::Entity::insert(asset_data_model) + .on_conflict( + OnConflict::columns([asset_data::Column::Id]) + .update_columns([ + asset_data::Column::ChainDataMutability, + asset_data::Column::ChainData, + asset_data::Column::MetadataUrl, + asset_data::Column::MetadataMutability, + asset_data::Column::SlotUpdated, + asset_data::Column::Reindex, + asset_data::Column::RawName, + asset_data::Column::RawSymbol, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset_data.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + let model = asset::ActiveModel { + id: Set(id.to_vec()), + owner, + owner_type: Set(ownership_type), + delegate, + frozen: Set(false), + supply, + supply_mint, + specification_version: Set(Some(SpecificationVersions::V1)), + specification_asset_class: Set(Some(class)), + tree_id: Set(None), + nonce: Set(Some(0)), + seq: Set(Some(0)), + leaf: Set(None), + compressed: Set(false), + compressible: Set(false), + royalty_target_type: Set(RoyaltyTargetType::Creators), + royalty_target: Set(None), + royalty_amount: Set(data.seller_fee_basis_points as i32), //basis points + asset_data: Set(Some(id.to_vec())), + slot_updated: Set(Some(slot_i)), + burnt: Set(false), + ..Default::default() + }; + let mut query = asset::Entity::insert(model) + .on_conflict( + OnConflict::columns([asset::Column::Id]) + .update_columns([ + asset::Column::Owner, + asset::Column::OwnerType, + asset::Column::Delegate, + asset::Column::Frozen, + asset::Column::Supply, + asset::Column::SupplyMint, + asset::Column::SpecificationVersion, + asset::Column::SpecificationAssetClass, + asset::Column::TreeId, + asset::Column::Nonce, + asset::Column::Seq, + asset::Column::Leaf, + asset::Column::Compressed, + asset::Column::Compressible, + asset::Column::RoyaltyTargetType, + asset::Column::RoyaltyTarget, + asset::Column::RoyaltyAmount, + asset::Column::AssetData, + asset::Column::SlotUpdated, + asset::Column::Burnt, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + let attachment = asset_v1_account_attachments::ActiveModel { + id: Set(edition_attachment_address.to_bytes().to_vec()), + slot_updated: Set(slot_i), + attachment_type: Set(V1AccountAttachments::MasterEditionV2), + ..Default::default() + }; + let query = asset_v1_account_attachments::Entity::insert(attachment) + .on_conflict( + OnConflict::columns([asset_v1_account_attachments::Column::Id]) + .do_nothing() + .to_owned(), + ) + .build(DbBackend::Postgres); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + let model = asset_authority::ActiveModel { + asset_id: Set(id.to_vec()), + authority: Set(authority), + seq: Set(0), + slot_updated: Set(slot_i), + ..Default::default() + }; + let mut query = asset_authority::Entity::insert(model) + .on_conflict( + OnConflict::columns([asset_authority::Column::AssetId]) + .update_columns([ + asset_authority::Column::Authority, + asset_authority::Column::Seq, + asset_authority::Column::SlotUpdated, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset_authority.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + if let Some(c) = &metadata.collection { + let model = asset_grouping::ActiveModel { + asset_id: Set(id.to_vec()), + group_key: Set("collection".to_string()), + group_value: Set(Some(c.key.to_string())), + verified: Set(Some(c.verified)), + seq: Set(None), + slot_updated: Set(Some(slot_i)), + ..Default::default() + }; + let mut query = asset_grouping::Entity::insert(model) + .on_conflict( + OnConflict::columns([ + asset_grouping::Column::AssetId, + asset_grouping::Column::GroupKey, + ]) + .update_columns([ + asset_grouping::Column::GroupKey, + asset_grouping::Column::GroupValue, + asset_grouping::Column::Seq, + asset_grouping::Column::SlotUpdated, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset_grouping.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + } + txn.commit().await?; + let creators = data.creators.unwrap_or_default(); + if !creators.is_empty() { + let mut creators_set = HashSet::new(); + let existing_creators: Vec = asset_creators::Entity::find() + .filter( + Condition::all() + .add(asset_creators::Column::AssetId.eq(id.to_vec())) + .add(asset_creators::Column::SlotUpdated.lt(slot_i)), + ) + .all(conn) + .await?; + if !existing_creators.is_empty() { + let mut db_creators = Vec::with_capacity(creators.len()); + for (i, c) in creators.into_iter().enumerate() { + if creators_set.contains(&c.address) { + continue; + } + db_creators.push(asset_creators::ActiveModel { + asset_id: Set(id.to_vec()), + creator: Set(c.address.to_bytes().to_vec()), + share: Set(c.share as i32), + verified: Set(c.verified), + seq: Set(Some(0)), + slot_updated: Set(Some(slot_i)), + position: Set(i as i16), + ..Default::default() + }); + creators_set.insert(c.address); + } + let txn = conn.begin().await?; + asset_creators::Entity::delete_many() + .filter( + Condition::all() + .add(asset_creators::Column::AssetId.eq(id.to_vec())) + .add(asset_creators::Column::SlotUpdated.lt(slot_i)), + ) + .exec(&txn) + .await?; + if !db_creators.is_empty() { + let mut query = asset_creators::Entity::insert_many(db_creators) + .on_conflict( + OnConflict::columns([ + asset_creators::Column::AssetId, + asset_creators::Column::Position, + ]) + .update_columns([ + asset_creators::Column::Creator, + asset_creators::Column::Share, + asset_creators::Column::Verified, + asset_creators::Column::Seq, + asset_creators::Column::SlotUpdated, + ]) + .to_owned(), + ) + .build(DbBackend::Postgres); + query.sql = format!( + "{} WHERE excluded.slot_updated > asset_creators.slot_updated", + query.sql + ); + txn.execute(query) + .await + .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; + } + txn.commit().await?; + } + } + if uri.is_empty() { + warn!( + "URI is empty for mint {}. Skipping background task.", + bs58::encode(mint).into_string() + ); + return Ok(None); + } + + let mut task = DownloadMetadata { + asset_data_id: id.to_vec(), + uri, + created_at: Some(Utc::now().naive_utc()), + }; + task.sanitize(); + let t = task.into_task_data()?; + Ok(Some(t)) +} From 974c90fe2add57fe26fa571a43d456635d8c62c6 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 20 Nov 2023 12:41:19 -0500 Subject: [PATCH 03/21] ci: add lock, fmt, clippy checks --- .github/workflows/build-api.yml | 32 ++++++++++++++++++++------------ .github/workflows/test.yml | 18 +++++++++--------- 2 files changed, 29 insertions(+), 21 deletions(-) diff --git a/.github/workflows/build-api.yml b/.github/workflows/build-api.yml index 15684355a..dfe23bce6 100644 --- a/.github/workflows/build-api.yml +++ b/.github/workflows/build-api.yml @@ -12,10 +12,10 @@ on: workflow_dispatch: push: branches: - - 'main' + - "main" env: - CARGO_TERM_COLOR: always + CARGO_TERM_COLOR: always jobs: build-api: @@ -33,19 +33,27 @@ jobs: - name: set build cache uses: actions/cache@v3 with: - path: | - ~/.cargo/bin/ - ~/.cargo/registry/index/ - ~/.cargo/registry/cache/ - ~/.cargo/git/db/ - digital-asset-rpc-infrastructure/target/ - key: ${{ matrix.os }}_digital-asset-rpc-infrastructure_${{ hashFiles('digital-asset-rpc-infrastructure/Cargo.lock') }} - restore-keys: | - ${{ matrix.os }}_digital-asset-rpc-infrastructure + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + digital-asset-rpc-infrastructure/target/ + key: ${{ matrix.os }}_digital-asset-rpc-infrastructure_${{ hashFiles('digital-asset-rpc-infrastructure/Cargo.lock') }} + restore-keys: | + ${{ matrix.os }}_digital-asset-rpc-infrastructure - name: build digital asset rpc infra run: cargo build --verbose --release + - name: build das_api + working-directory: das_api + run: cargo build --verbose --release + + - name: build migration + working-directory: migration + run: cargo build --verbose --release + - name: rename binaries for ubuntu22 release if: matrix.os == 'ubuntu-22.04' run: | @@ -54,7 +62,7 @@ jobs: mv target/release/migration target/release/migration22 mv target/release/das_api target/release/das_api22 - # This steps can be omited to save space, are mostly in place to validate binaries (manually) and path to them + # This steps can be omited to save space, are mostly in place to validate binaries (manually) and path to them # Omiting this will save on storage consumption on the account - name: Publish artifact if: matrix.os == 'ubuntu-22.04' diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 4ced2cd37..4f4b4111d 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -8,11 +8,11 @@ on: pull_request: push: branches: - - 'main' + - "main" workflow_dispatch: env: - CARGO_TERM_COLOR: always + CARGO_TERM_COLOR: always jobs: test: @@ -25,13 +25,13 @@ jobs: - name: set build cache uses: actions/cache@v3 with: - path: | - ~/.cargo/bin/ - ~/.cargo/registry/index/ - ~/.cargo/registry/cache/ - ~/.cargo/git/db/ - digital-asset-rpc-infrastructure/target/ - key: cargo-${{ hashFiles('**/Cargo.lock') }}-0001 + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + digital-asset-rpc-infrastructure/target/ + key: cargo-${{ hashFiles('**/Cargo.lock') }}-0001 # Cargo.lock - name: Check lock file From 788973e2724a50405a76b68127ec6ba936299bdc Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 20 Nov 2023 12:57:28 -0500 Subject: [PATCH 04/21] include migration to workspace --- .github/workflows/build-api.yml | 4 - Cargo.lock | 1681 +++++++++-------- ...131_140613_change_token_account_indexes.rs | 11 + 3 files changed, 926 insertions(+), 770 deletions(-) diff --git a/.github/workflows/build-api.yml b/.github/workflows/build-api.yml index dfe23bce6..8082f52a9 100644 --- a/.github/workflows/build-api.yml +++ b/.github/workflows/build-api.yml @@ -50,10 +50,6 @@ jobs: working-directory: das_api run: cargo build --verbose --release - - name: build migration - working-directory: migration - run: cargo build --verbose --release - - name: rename binaries for ubuntu22 release if: matrix.os == 'ubuntu-22.04' run: | diff --git a/Cargo.lock b/Cargo.lock index 90e706291..8a5e4dd91 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,8 +18,8 @@ version = "0.7.12" dependencies = [ "anyhow", "bs58 0.4.0", - "clap 4.4.8", - "env_logger 0.10.0", + "clap 4.5.4", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -93,11 +93,11 @@ dependencies = [ [[package]] name = "ahash" -version = "0.7.6" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", "once_cell", "version_check", ] @@ -109,7 +109,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cd7d5a2cecb58716e47d67d5703a249964b14c7be1ec3cad3affc295b2d1c35d" dependencies = [ "cfg-if", - "getrandom 0.2.10", + "getrandom 0.2.14", "once_cell", "version_check", "zerocopy", @@ -117,9 +117,9 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "1.1.2" +version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" dependencies = [ "memchr", ] @@ -170,7 +170,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7f2a3e1df4685f18d12a943a9f2a7456305401af21a07c9fe076ef9ecd6e400" dependencies = [ "anchor-syn", - "bs58 0.5.0", + "bs58 0.5.1", "proc-macro2", "quote", "syn 1.0.109", @@ -295,7 +295,7 @@ dependencies = [ "bincode", "borsh 0.10.3", "bytemuck", - "getrandom 0.2.10", + "getrandom 0.2.14", "solana-program", "thiserror", ] @@ -307,7 +307,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9101b84702fed2ea57bd22992f75065da5648017135b844283a2f6d74f27825" dependencies = [ "anyhow", - "bs58 0.5.0", + "bs58 0.5.1", "heck 0.3.3", "proc-macro2", "quote", @@ -344,9 +344,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.4" +version = "0.6.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44" +checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb" dependencies = [ "anstyle", "anstyle-parse", @@ -358,49 +358,49 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.4" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87" +checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc" [[package]] name = "anstyle-parse" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140" +checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.0.0" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b" +checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "anstyle-wincon" -version = "3.0.1" +version = "3.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628" +checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7" dependencies = [ "anstyle", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "anyhow" -version = "1.0.75" +version = "1.0.82" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" +checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519" [[package]] name = "arc-swap" -version = "1.6.0" +version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6" +checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" [[package]] name = "ark-bn254" @@ -550,7 +550,7 @@ dependencies = [ "num-traits", "rusticata-macros", "thiserror", - "time 0.3.29", + "time 0.3.35", ] [[package]] @@ -605,22 +605,22 @@ dependencies = [ [[package]] name = "async-channel" -version = "2.1.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d37875bd9915b7d67c2f117ea2c30a0989874d0b2cb694fe25403c85763c0c9e" +checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" dependencies = [ "concurrent-queue", - "event-listener 3.1.0", - "event-listener-strategy", + "event-listener 5.3.0", + "event-listener-strategy 0.5.1", "futures-core", "pin-project-lite", ] [[package]] name = "async-compression" -version = "0.4.3" +version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb42b2197bf15ccb092b62c74515dbd8b86d0effd934795f6687c93b6e679a2c" +checksum = "07dbbf24db18d609b1462965249abdf49129ccad073ec257da372adc83259c60" dependencies = [ "brotli", "flate2", @@ -632,30 +632,30 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.7.2" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc5ea910c42e5ab19012bab31f53cb4d63d54c3a27730f9a833a88efcf4bb52d" +checksum = "5f98c37cf288e302c16ef6c8472aad1e034c6c84ce5ea7b8101c98eb4a802fee" dependencies = [ - "async-lock 3.1.1", + "async-lock 3.3.0", "async-task", "concurrent-queue", - "fastrand 2.0.1", - "futures-lite 2.0.1", + "fastrand 2.0.2", + "futures-lite 2.3.0", "slab", ] [[package]] name = "async-global-executor" -version = "2.3.1" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776" +checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" dependencies = [ - "async-channel 1.9.0", + "async-channel 2.2.0", "async-executor", - "async-io", - "async-lock 2.8.0", + "async-io 2.3.2", + "async-lock 3.3.0", "blocking", - "futures-lite 1.13.0", + "futures-lite 2.3.0", "once_cell", "tokio", ] @@ -673,13 +673,32 @@ dependencies = [ "futures-lite 1.13.0", "log", "parking", - "polling", + "polling 2.8.0", "rustix 0.37.27", "slab", - "socket2 0.4.9", + "socket2 0.4.10", "waker-fn", ] +[[package]] +name = "async-io" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcccb0f599cfa2f8ace422d3555572f47424da5648a4382a9dd0310ff8210884" +dependencies = [ + "async-lock 3.3.0", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite 2.3.0", + "parking", + "polling 3.6.0", + "rustix 0.38.32", + "slab", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "async-lock" version = "2.8.0" @@ -691,12 +710,12 @@ dependencies = [ [[package]] name = "async-lock" -version = "3.1.1" +version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "655b9c7fe787d3b25cc0f804a1a8401790f0c5bc395beb5a64dc77d8de079105" +checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b" dependencies = [ - "event-listener 3.1.0", - "event-listener-strategy", + "event-listener 4.0.3", + "event-listener-strategy 0.4.0", "pin-project-lite", ] @@ -718,7 +737,7 @@ dependencies = [ "async-attributes", "async-channel 1.9.0", "async-global-executor", - "async-io", + "async-io 1.13.0", "async-lock 2.8.0", "crossbeam-utils", "futures-channel", @@ -755,24 +774,24 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "async-task" -version = "4.5.0" +version = "4.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4eb2cdb97421e01129ccb49169d8279ed21e829929144f4a22a6e54ac549ca1" +checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799" [[package]] name = "async-trait" -version = "0.1.73" +version = "0.1.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0" +checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -818,17 +837,17 @@ dependencies = [ [[package]] name = "autocfg" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" [[package]] name = "backon" -version = "0.4.1" +version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c1a6197b2120bb2185a267f6515038558b019e92b832bb0320e96d66268dcf9" +checksum = "d67782c3f868daa71d3533538e98a8e13713231969def7536e8039606fc46bf0" dependencies = [ - "fastrand 1.9.0", + "fastrand 2.0.2", "futures-core", "pin-project", "tokio", @@ -836,9 +855,9 @@ dependencies = [ [[package]] name = "backtrace" -version = "0.3.69" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" dependencies = [ "addr2line", "cc", @@ -876,9 +895,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" [[package]] name = "base64" -version = "0.21.4" +version = "0.21.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" [[package]] name = "base64" @@ -906,7 +925,7 @@ name = "bgtask_creator" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", "futures", "lazy_static", @@ -938,9 +957,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" dependencies = [ "serde", ] @@ -968,9 +987,9 @@ dependencies = [ [[package]] name = "blake3" -version = "1.5.0" +version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87" +checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52" dependencies = [ "arrayref", "arrayvec", @@ -1041,12 +1060,12 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118" dependencies = [ - "async-channel 2.1.0", - "async-lock 3.1.1", + "async-channel 2.2.0", + "async-lock 3.3.0", "async-task", - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-io", - "futures-lite 2.0.1", + "futures-lite 2.3.0", "piper", "tracing", ] @@ -1071,6 +1090,16 @@ dependencies = [ "hashbrown 0.13.2", ] +[[package]] +name = "borsh" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0901fc8eb0aca4c83be0106d6f2db17d86a08dfc2c25f0e84464bf381158add6" +dependencies = [ + "borsh-derive 1.4.0", + "cfg_aliases", +] + [[package]] name = "borsh-derive" version = "0.9.3" @@ -1097,6 +1126,20 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "borsh-derive" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51670c3aa053938b0ee3bd67c3817e471e626151131b934038e83c5bf8de48f5" +dependencies = [ + "once_cell", + "proc-macro-crate 3.1.0", + "proc-macro2", + "quote", + "syn 2.0.58", + "syn_derive", +] + [[package]] name = "borsh-derive-internal" version = "0.9.3" @@ -1143,9 +1186,9 @@ dependencies = [ [[package]] name = "brotli" -version = "3.4.0" +version = "4.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "516074a47ef4bce09577a3b379392300159ce5b1ba2e501ff1c819950066100f" +checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1154,9 +1197,9 @@ dependencies = [ [[package]] name = "brotli-decompressor" -version = "2.5.0" +version = "3.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da74e2b81409b1b743f8f0c62cc6254afefb8b8e50bbfe3735550f7aeefa3448" +checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1170,18 +1213,18 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3" [[package]] name = "bs58" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" +checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" dependencies = [ "tinyvec", ] [[package]] name = "bstr" -version = "1.8.0" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "542f33a8835a0884b006a0c3df3dadd99c0c3f296ed26c2fdc8028e01ad6230c" +checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706" dependencies = [ "memchr", "serde", @@ -1189,9 +1232,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.14.0" +version = "3.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" [[package]] name = "bv" @@ -1205,9 +1248,9 @@ dependencies = [ [[package]] name = "bytecheck" -version = "0.6.11" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627" +checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2" dependencies = [ "bytecheck_derive", "ptr_meta", @@ -1216,9 +1259,9 @@ dependencies = [ [[package]] name = "bytecheck_derive" -version = "0.6.11" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61" +checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659" dependencies = [ "proc-macro2", "quote", @@ -1236,13 +1279,13 @@ dependencies = [ [[package]] name = "bytemuck_derive" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "965ab7eb5f8f97d2a083c799f3a1b994fc397b2fe2da5d1da1626ce15a39f2b1" +checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1253,9 +1296,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" +checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" [[package]] name = "cadence" @@ -1287,9 +1330,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.0.83" +version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +checksum = "2678b2e3449475e95b0aa6f9b506a28e61b3dc8996592b983695e8ebb58a8b41" dependencies = [ "jobserver", "libc", @@ -1301,11 +1344,17 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cfg_aliases" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" + [[package]] name = "chrono" -version = "0.4.31" +version = "0.4.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" +checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e" dependencies = [ "android-tzdata", "iana-time-zone", @@ -1313,7 +1362,7 @@ dependencies = [ "num-traits", "serde", "wasm-bindgen", - "windows-targets 0.48.5", + "windows-targets 0.52.4", ] [[package]] @@ -1354,29 +1403,29 @@ dependencies = [ "once_cell", "strsim 0.10.0", "termcolor", - "textwrap 0.16.0", + "textwrap 0.16.1", ] [[package]] name = "clap" -version = "4.4.8" +version = "4.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64" +checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0" dependencies = [ "clap_builder", - "clap_derive 4.4.7", + "clap_derive 4.5.4", ] [[package]] name = "clap_builder" -version = "4.4.8" +version = "4.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc" +checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" dependencies = [ "anstream", "anstyle", - "clap_lex 0.6.0", - "strsim 0.10.0", + "clap_lex 0.7.0", + "strsim 0.11.1", ] [[package]] @@ -1394,14 +1443,14 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.4.7" +version = "4.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" +checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64" dependencies = [ - "heck 0.4.1", + "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1415,9 +1464,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.6.0" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" +checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" [[package]] name = "colorchoice" @@ -1440,9 +1489,9 @@ dependencies = [ [[package]] name = "combine" -version = "4.6.6" +version = "4.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" +checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" dependencies = [ "bytes", "futures-core", @@ -1454,24 +1503,24 @@ dependencies = [ [[package]] name = "concurrent-queue" -version = "2.3.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f057a694a54f12365049b0958a1685bb52d567f5593b355fbf685838e873d400" +checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363" dependencies = [ "crossbeam-utils", ] [[package]] name = "console" -version = "0.15.7" +version = "0.15.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8" +checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" dependencies = [ "encode_unicode", "lazy_static", "libc", "unicode-width", - "windows-sys 0.45.0", + "windows-sys 0.52.0", ] [[package]] @@ -1508,9 +1557,9 @@ checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" [[package]] name = "core-foundation" -version = "0.9.3" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" dependencies = [ "core-foundation-sys", "libc", @@ -1518,95 +1567,85 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.4" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" +checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" [[package]] name = "cpufeatures" -version = "0.2.9" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1" +checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" dependencies = [ "libc", ] [[package]] name = "crc" -version = "3.0.1" +version = "3.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe" +checksum = "69e6e4d7b33a94f0991c26729976b10ebde1d34c3ee82408fb536164fa10d636" dependencies = [ "crc-catalog", ] [[package]] name = "crc-catalog" -version = "2.2.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484" +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" [[package]] name = "crc32fast" -version = "1.3.2" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" dependencies = [ "cfg-if", ] [[package]] name = "crossbeam-channel" -version = "0.5.8" +version = "0.5.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200" +checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95" dependencies = [ - "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-deque" -version = "0.8.3" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef" +checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" dependencies = [ - "cfg-if", "crossbeam-epoch", "crossbeam-utils", ] [[package]] name = "crossbeam-epoch" -version = "0.9.15" +version = "0.9.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" dependencies = [ - "autocfg", - "cfg-if", "crossbeam-utils", - "memoffset 0.9.0", - "scopeguard", ] [[package]] name = "crossbeam-queue" -version = "0.3.8" +version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add" +checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35" dependencies = [ - "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-utils" -version = "0.8.16" +version = "0.8.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" -dependencies = [ - "cfg-if", -] +checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345" [[package]] name = "crunchy" @@ -1659,9 +1698,9 @@ dependencies = [ [[package]] name = "darling" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e" +checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391" dependencies = [ "darling_core", "darling_macro", @@ -1669,27 +1708,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621" +checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim 0.10.0", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "darling_macro" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5" +checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f" dependencies = [ "darling_core", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1700,7 +1739,7 @@ dependencies = [ "backon", "cadence", "cadence-macros", - "clap 4.4.8", + "clap 4.5.4", "figment", "plerkle_messenger", "solana-account-decoder", @@ -1722,10 +1761,10 @@ dependencies = [ "borsh 0.10.3", "cadence", "cadence-macros", - "clap 4.4.8", + "clap 4.5.4", "das-core", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -1755,7 +1794,7 @@ dependencies = [ "cadence", "cadence-macros", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "figment", "hyper", "jsonrpsee", @@ -1797,17 +1836,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" dependencies = [ "cfg-if", - "hashbrown 0.14.1", + "hashbrown 0.14.2", "lock_api", "once_cell", - "parking_lot_core 0.9.8", + "parking_lot_core 0.9.9", ] [[package]] name = "data-encoding" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308" +checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" [[package]] name = "der" @@ -1834,10 +1873,11 @@ dependencies = [ [[package]] name = "deranged" -version = "0.3.8" +version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946" +checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" dependencies = [ + "powerfmt", "serde", ] @@ -1953,7 +1993,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1976,7 +2016,7 @@ checksum = "a6cbae11b3de8fce2a456e8ea3dada226b35fe791f0dc1d360c0941f0bb681f3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1987,9 +2027,9 @@ checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" [[package]] name = "dyn-clone" -version = "1.0.14" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23d2f3407d9a573d666de4b5bdf10569d73ca9478087346697dcbae6244bfbcd" +checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" [[package]] name = "eager" @@ -2034,9 +2074,9 @@ dependencies = [ [[package]] name = "either" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" +checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a" dependencies = [ "serde", ] @@ -2049,31 +2089,31 @@ checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" [[package]] name = "encoding_rs" -version = "0.8.33" +version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" +checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" dependencies = [ "cfg-if", ] [[package]] name = "enum-iterator" -version = "1.4.1" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7add3873b5dd076766ee79c8e406ad1a472c385476b9e38849f8eec24f1be689" +checksum = "9fd242f399be1da0a5354aa462d57b4ab2b4ee0683cc552f7c007d2d12d36e94" dependencies = [ "enum-iterator-derive", ] [[package]] name = "enum-iterator-derive" -version = "1.2.1" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eecf8589574ce9b895052fa12d69af7a233f99e6107f5cb8dd1044f2a17bfdcb" +checksum = "03cdc46ec28bd728e67540c528013c6a10eb69a02eb31078a1bda695438cbfb8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -2091,9 +2131,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.10.0" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0" +checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580" dependencies = [ "humantime", "is-terminal", @@ -2110,12 +2150,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "errno" -version = "0.3.5" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860" +checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -2126,9 +2166,20 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" [[package]] name = "event-listener" -version = "3.1.0" +version = "4.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d93877bcde0eb80ca09131a08d23f0a5c18a620b01db137dba666d18cd9b30c2" +checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e" +dependencies = [ + "concurrent-queue", + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9944b8ca13534cdfb2800775f8dd4902ff3fc75a50101466decadfdf322a24" dependencies = [ "concurrent-queue", "parking", @@ -2137,11 +2188,21 @@ dependencies = [ [[package]] name = "event-listener-strategy" -version = "0.3.0" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3" +dependencies = [ + "event-listener 4.0.3", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d96b852f1345da36d551b9473fa1e2b1eb5c5195585c6c018118bc92a8d91160" +checksum = "332f51cb23d20b0de8458b86580878211da09bcd4503cb579c225b3d124cabb3" dependencies = [ - "event-listener 3.1.0", + "event-listener 5.3.0", "pin-project-lite", ] @@ -2166,9 +2227,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.0.1" +version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" +checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984" [[package]] name = "feature-probe" @@ -2183,7 +2244,7 @@ dependencies = [ "anyhow", "async-trait", "borsh 0.10.3", - "clap 4.4.8", + "clap 4.5.4", "mpl-bubblegum", "solana-account-decoder", "solana-client", @@ -2194,15 +2255,15 @@ dependencies = [ [[package]] name = "figment" -version = "0.10.11" +version = "0.10.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a014ac935975a70ad13a3bff2463b1c1b083b35ae4cb6309cfc59476aa7a181f" +checksum = "fdefe49ed1057d124dc81a0681c30dd07de56ad96e32adc7b64e8f28eaab31c4" dependencies = [ "atomic 0.6.0", "pear", "serde", "serde_yaml", - "toml 0.8.8", + "toml 0.8.12", "uncased", "version_check", ] @@ -2225,9 +2286,9 @@ dependencies = [ [[package]] name = "flate2" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6c98ee8095e9d1dcbf2fcc6d95acccb90d1c81db1e44725c6a984b1dbdfb010" +checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" dependencies = [ "crc32fast", "miniz_oxide", @@ -2256,9 +2317,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "form_urlencoded" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" dependencies = [ "percent-encoding", ] @@ -2292,9 +2353,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40" +checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" dependencies = [ "futures-channel", "futures-core", @@ -2307,9 +2368,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2" +checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" dependencies = [ "futures-core", "futures-sink", @@ -2317,15 +2378,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c" +checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" [[package]] name = "futures-executor" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0" +checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" dependencies = [ "futures-core", "futures-task", @@ -2345,9 +2406,9 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964" +checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" [[package]] name = "futures-lite" @@ -2366,46 +2427,45 @@ dependencies = [ [[package]] name = "futures-lite" -version = "2.0.1" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3831c2651acb5177cbd83943f3d9c8912c5ad03c76afcc0e9511ba568ec5ebb" +checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5" dependencies = [ - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-core", "futures-io", - "memchr", "parking", "pin-project-lite", ] [[package]] name = "futures-macro" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72" +checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "futures-sink" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e" +checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" [[package]] name = "futures-task" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65" +checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" [[package]] name = "futures-util" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533" +checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" dependencies = [ "futures-channel", "futures-core", @@ -2461,9 +2521,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.10" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" +checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c" dependencies = [ "cfg-if", "js-sys", @@ -2474,21 +2534,21 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.0" +version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" +checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" [[package]] name = "globset" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d" +checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1" dependencies = [ "aho-corasick", "bstr", - "fnv", "log", - "regex", + "regex-automata 0.4.6", + "regex-syntax 0.8.3", ] [[package]] @@ -2516,9 +2576,9 @@ dependencies = [ [[package]] name = "h2" -version = "0.3.21" +version = "0.3.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833" +checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" dependencies = [ "bytes", "fnv", @@ -2526,7 +2586,7 @@ dependencies = [ "futures-sink", "futures-util", "http", - "indexmap 1.9.3", + "indexmap 2.2.6", "slab", "tokio", "tokio-util", @@ -2548,7 +2608,7 @@ version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", ] [[package]] @@ -2557,7 +2617,7 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", ] [[package]] @@ -2571,9 +2631,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.14.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12" +checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156" dependencies = [ "ahash 0.8.5", "allocator-api2", @@ -2585,7 +2645,7 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7" dependencies = [ - "hashbrown 0.14.1", + "hashbrown 0.14.2", ] [[package]] @@ -2623,9 +2683,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.3.3" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" +checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" [[package]] name = "hex" @@ -2641,9 +2701,9 @@ checksum = "12cb882ccb290b8646e554b157ab0b71e64e8d5bef775cd66b6531e52d302669" [[package]] name = "hkdf" -version = "0.12.3" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" dependencies = [ "hmac 0.12.1", ] @@ -2680,9 +2740,9 @@ dependencies = [ [[package]] name = "http" -version = "0.2.9" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" dependencies = [ "bytes", "fnv", @@ -2691,9 +2751,9 @@ dependencies = [ [[package]] name = "http-body" -version = "0.4.5" +version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" +checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" dependencies = [ "bytes", "http", @@ -2726,9 +2786,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.27" +version = "0.14.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" +checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" dependencies = [ "bytes", "futures-channel", @@ -2741,7 +2801,7 @@ dependencies = [ "httpdate", "itoa", "pin-project-lite", - "socket2 0.4.9", + "socket2 0.5.6", "tokio", "tower-service", "tracing", @@ -2750,14 +2810,14 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.24.1" +version = "0.24.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" dependencies = [ "futures-util", "http", "hyper", - "rustls 0.21.7", + "rustls 0.21.10", "tokio", "tokio-rustls 0.24.1", ] @@ -2777,16 +2837,16 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.57" +version = "0.1.60" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613" +checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" dependencies = [ "android_system_properties", "core-foundation-sys", "iana-time-zone-haiku", "js-sys", "wasm-bindgen", - "windows", + "windows-core", ] [[package]] @@ -2806,9 +2866,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" [[package]] name = "idna" -version = "0.4.0" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" +checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" dependencies = [ "unicode-bidi", "unicode-normalization", @@ -2843,25 +2903,25 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.0.2" +version = "2.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897" +checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" dependencies = [ "equivalent", - "hashbrown 0.14.1", + "hashbrown 0.14.2", "serde", ] [[package]] name = "indicatif" -version = "0.17.7" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb28741c9db9a713d93deb3bb9515c20788cef5815265bee4980e87bde7e0f25" +checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3" dependencies = [ "console", "instant", "number_prefix", - "portable-atomic 1.4.3", + "portable-atomic 1.6.0", "unicode-width", ] @@ -2873,16 +2933,15 @@ checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb" [[package]] name = "insta" -version = "1.35.1" +version = "1.38.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c985c1bef99cf13c58fade470483d81a2bfe846ebde60ed28cc2dddec2df9e2" +checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc" dependencies = [ "console", "lazy_static", "linked-hash-map", "serde", "similar", - "yaml-rust", ] [[package]] @@ -2934,26 +2993,26 @@ version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2" dependencies = [ - "hermit-abi 0.3.3", + "hermit-abi 0.3.9", "libc", "windows-sys 0.48.0", ] [[package]] name = "ipnet" -version = "2.8.0" +version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6" +checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" [[package]] name = "is-terminal" -version = "0.4.9" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b" +checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b" dependencies = [ - "hermit-abi 0.3.3", - "rustix 0.38.18", - "windows-sys 0.48.0", + "hermit-abi 0.3.9", + "libc", + "windows-sys 0.52.0", ] [[package]] @@ -2967,33 +3026,33 @@ dependencies = [ [[package]] name = "itertools" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" dependencies = [ "either", ] [[package]] name = "itoa" -version = "1.0.9" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" +checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" [[package]] name = "jobserver" -version = "0.1.26" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2" +checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6" dependencies = [ "libc", ] [[package]] name = "js-sys" -version = "0.3.64" +version = "0.3.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a" +checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" dependencies = [ "wasm-bindgen", ] @@ -3114,18 +3173,18 @@ dependencies = [ [[package]] name = "kaigan" -version = "0.2.2" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a26f49495f94a283312e7ef45a243540ef20c9356bb01c8d84a61ac8ba5339b" +checksum = "e623cca1f0e2a0919032c1bdabbf81dd9aa34658d5066aca7bb90d608317ab91" dependencies = [ "borsh 0.10.3", ] [[package]] name = "keccak" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" +checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" dependencies = [ "cpufeatures", ] @@ -3147,9 +3206,19 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.149" +version = "0.2.153" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b" +checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" + +[[package]] +name = "libredox" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +dependencies = [ + "bitflags 2.5.0", + "libc", +] [[package]] name = "libsecp256k1" @@ -3225,9 +3294,9 @@ checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519" [[package]] name = "linux-raw-sys" -version = "0.4.10" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f" +checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c" [[package]] name = "load_generation" @@ -3246,9 +3315,9 @@ dependencies = [ [[package]] name = "lock_api" -version = "0.4.10" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" dependencies = [ "autocfg", "scopeguard", @@ -3256,9 +3325,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.20" +version = "0.4.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" +checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" dependencies = [ "value-bag", ] @@ -3284,9 +3353,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.6.4" +version = "2.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" +checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" [[package]] name = "memmap2" @@ -3308,9 +3377,9 @@ dependencies = [ [[package]] name = "memoffset" -version = "0.9.0" +version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" dependencies = [ "autocfg", ] @@ -3345,7 +3414,7 @@ version = "0.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b9b8653cec6897f73b519a43fba5ee3d50f62fe9af80b428accdcc093b4a849" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", "metrics-macros", "portable-atomic 0.3.20", ] @@ -3395,18 +3464,18 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" [[package]] name = "miniz_oxide" -version = "0.7.1" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" +checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" dependencies = [ "adler", ] [[package]] name = "mio" -version = "0.8.8" +version = "0.8.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2" +checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" dependencies = [ "libc", "wasi 0.11.0+wasi-snapshot-preview1", @@ -3438,22 +3507,22 @@ dependencies = [ "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.6.1", + "serde_with 3.7.0", "solana-program", "thiserror", ] [[package]] name = "mpl-token-metadata" -version = "4.1.1" +version = "4.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4b2de608098eb2ef2a5392069dea83084967e25a4d69d0380a6bb02454fc0fe" +checksum = "caf0f61b553e424a6234af1268456972ee66c2222e1da89079242251fa7479e5" dependencies = [ "borsh 0.10.3", "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.6.1", + "serde_with 3.7.0", "solana-program", "thiserror", ] @@ -3487,7 +3556,7 @@ dependencies = [ "cadence", "cadence-macros", "chrono", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", "figment", "flatbuffers", @@ -3595,6 +3664,12 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-conv" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" + [[package]] name = "num-derive" version = "0.3.3" @@ -3608,30 +3683,29 @@ dependencies = [ [[package]] name = "num-derive" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfb77679af88f8b125209d354a202862602672222e7f2313fdd6dc349bad4712" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "num-integer" -version = "0.1.45" +version = "0.1.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" dependencies = [ - "autocfg", "num-traits", ] [[package]] name = "num-iter" -version = "0.1.43" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" +checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9" dependencies = [ "autocfg", "num-integer", @@ -3652,9 +3726,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.17" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a" dependencies = [ "autocfg", ] @@ -3665,7 +3739,7 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi 0.3.3", + "hermit-abi 0.3.9", "libc", ] @@ -3696,7 +3770,7 @@ dependencies = [ "proc-macro-crate 1.3.1", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3705,10 +3779,10 @@ version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b" dependencies = [ - "proc-macro-crate 1.3.1", + "proc-macro-crate 3.1.0", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3719,9 +3793,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" [[package]] name = "object" -version = "0.32.1" +version = "0.32.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" +checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" dependencies = [ "memchr", ] @@ -3743,9 +3817,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "opaque-debug" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "open-rpc-derive" @@ -3773,11 +3847,11 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.57" +version = "0.10.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bac25ee399abb46215765b1cb35bc0212377e58a061560d8b29b024fd0430e7c" +checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.5.0", "cfg-if", "foreign-types", "libc", @@ -3794,7 +3868,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3805,9 +3879,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.93" +version = "0.9.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d" +checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2" dependencies = [ "cc", "libc", @@ -3874,7 +3948,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" dependencies = [ "lock_api", - "parking_lot_core 0.9.8", + "parking_lot_core 0.9.9", ] [[package]] @@ -3893,13 +3967,13 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.8" +version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.3.5", + "redox_syscall 0.4.1", "smallvec", "windows-targets 0.48.5", ] @@ -3930,9 +4004,9 @@ dependencies = [ [[package]] name = "pear" -version = "0.2.7" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61a386cd715229d399604b50d1361683fe687066f42d56f54be995bc6868f71c" +checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467" dependencies = [ "inlinable_string", "pear_codegen", @@ -3941,14 +4015,14 @@ dependencies = [ [[package]] name = "pear_codegen" -version = "0.2.7" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da9f0f13dac8069c139e8300a6510e3f4143ecf5259c60b116a9b271b4ca0d54" +checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147" dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3962,9 +4036,9 @@ dependencies = [ [[package]] name = "percent-encoding" -version = "2.3.0" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" [[package]] name = "percentage" @@ -3977,29 +4051,29 @@ dependencies = [ [[package]] name = "pin-project" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0" +checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690" +checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "pin-project-lite" -version = "0.2.13" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" +checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" [[package]] name = "pin-utils" @@ -4014,7 +4088,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4" dependencies = [ "atomic-waker", - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-io", ] @@ -4031,9 +4105,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.27" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" +checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" [[package]] name = "plain" @@ -4043,9 +4117,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" [[package]] name = "plerkle_messenger" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2f8e4e8975dcd2dbf94c7f84409096f0a0e5af287eabc9a212704e9e325ec84" +checksum = "a94c75e3178528c45bca0b7d515bdc6a3733b5f67d5b37b8a085cf6d7f81e3f2" dependencies = [ "async-mutex", "async-trait", @@ -4091,6 +4165,21 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "polling" +version = "3.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0c976a60b2d7e99d6f229e414670a9b85d13ac305cc6d1e9c134de58c5aaaf6" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi 0.3.9", + "pin-project-lite", + "rustix 0.38.32", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "polyval" version = "0.5.3" @@ -4109,14 +4198,20 @@ version = "0.3.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e30165d31df606f5726b090ec7592c308a0eaf61721ff64c9a3018e344a8753e" dependencies = [ - "portable-atomic 1.4.3", + "portable-atomic 1.6.0", ] [[package]] name = "portable-atomic" -version = "1.4.3" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31114a898e107c51bb1609ffaf55a0e011cf6a4d7f1170d0015a165082c0338b" +checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0" + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" @@ -4143,6 +4238,15 @@ dependencies = [ "toml_edit 0.19.15", ] +[[package]] +name = "proc-macro-crate" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284" +dependencies = [ + "toml_edit 0.21.1", +] + [[package]] name = "proc-macro-error" version = "1.0.4" @@ -4169,9 +4273,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.69" +version = "1.0.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" dependencies = [ "unicode-ident", ] @@ -4184,7 +4288,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "version_check", "yansi", ] @@ -4282,7 +4386,7 @@ checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -4296,7 +4400,7 @@ dependencies = [ "quinn-proto", "quinn-udp", "rustc-hash", - "rustls 0.21.7", + "rustls 0.21.10", "thiserror", "tokio", "tracing", @@ -4312,7 +4416,7 @@ dependencies = [ "rand 0.8.5", "ring 0.16.20", "rustc-hash", - "rustls 0.21.7", + "rustls 0.21.10", "rustls-native-certs", "slab", "thiserror", @@ -4328,16 +4432,16 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7" dependencies = [ "bytes", "libc", - "socket2 0.5.4", + "socket2 0.5.6", "tracing", "windows-sys 0.48.0", ] [[package]] name = "quote" -version = "1.0.33" +version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" dependencies = [ "proc-macro2", ] @@ -4445,7 +4549,7 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", ] [[package]] @@ -4468,9 +4572,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.8.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" dependencies = [ "either", "rayon-core", @@ -4478,9 +4582,9 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.12.0" +version = "1.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" +checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" dependencies = [ "crossbeam-deque", "crossbeam-utils", @@ -4494,7 +4598,7 @@ checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b" dependencies = [ "pem", "ring 0.16.20", - "time 0.3.29", + "time 0.3.35", "yasna", ] @@ -4516,7 +4620,7 @@ dependencies = [ "arc-swap", "async-trait", "bytes", - "combine 4.6.6", + "combine 4.6.7", "futures", "futures-util", "itoa", @@ -4542,34 +4646,34 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.3.5" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" dependencies = [ "bitflags 1.3.2", ] [[package]] name = "redox_users" -version = "0.4.3" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" +checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891" dependencies = [ - "getrandom 0.2.10", - "redox_syscall 0.2.16", + "getrandom 0.2.14", + "libredox", "thiserror", ] [[package]] name = "regex" -version = "1.9.6" +version = "1.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff" +checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.3.9", - "regex-syntax 0.7.5", + "regex-automata 0.4.6", + "regex-syntax 0.8.3", ] [[package]] @@ -4583,13 +4687,13 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.3.9" +version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9" +checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.7.5", + "regex-syntax 0.8.3", ] [[package]] @@ -4600,27 +4704,27 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.7.5" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" +checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" [[package]] name = "rend" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2571463863a6bd50c32f94402933f03457a3fbaf697a707c5be741e459f08fd" +checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c" dependencies = [ "bytecheck", ] [[package]] name = "reqwest" -version = "0.11.22" +version = "0.11.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" dependencies = [ "async-compression", - "base64 0.21.4", + "base64 0.21.7", "bytes", "encoding_rs", "futures-core", @@ -4639,11 +4743,12 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls 0.21.7", + "rustls 0.21.10", "rustls-pemfile", "serde", "serde_json", "serde_urlencoded", + "sync_wrapper", "system-configuration", "tokio", "tokio-native-tls", @@ -4654,7 +4759,7 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "webpki-roots 0.25.2", + "webpki-roots 0.25.4", "winreg", ] @@ -4675,26 +4780,28 @@ dependencies = [ [[package]] name = "ring" -version = "0.17.2" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "911b295d2d302948838c8ac142da1ee09fa7863163b44e6715bc9357905878b8" +checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" dependencies = [ "cc", - "getrandom 0.2.10", + "cfg-if", + "getrandom 0.2.14", "libc", "spin 0.9.8", "untrusted 0.9.0", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "rkyv" -version = "0.7.42" +version = "0.7.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58" +checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0" dependencies = [ "bitvec", "bytecheck", + "bytes", "hashbrown 0.12.3", "ptr_meta", "rend", @@ -4706,9 +4813,9 @@ dependencies = [ [[package]] name = "rkyv_derive" -version = "0.7.42" +version = "0.7.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2e06b915b5c230a17d7a736d1e2e63ee753c256a8614ef3f5147b13a4f5541d" +checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65" dependencies = [ "proc-macro2", "quote", @@ -4751,12 +4858,12 @@ dependencies = [ [[package]] name = "rust_decimal" -version = "1.32.0" +version = "1.35.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4c4216490d5a413bc6d10fa4742bd7d4955941d062c0ef873141d6b0e7b30fd" +checksum = "1790d1c4c0ca81211399e0e0af16333276f375209e71a37b67698a373db5b47a" dependencies = [ "arrayvec", - "borsh 0.10.3", + "borsh 1.4.0", "bytes", "num-traits", "rand 0.8.5", @@ -4779,9 +4886,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-serialize" -version = "0.3.24" +version = "0.3.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda" +checksum = "fe834bc780604f4674073badbad26d7219cadfb4a2275802db12cbae17498401" [[package]] name = "rustc_version" @@ -4817,15 +4924,15 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.18" +version = "0.38.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a74ee2d7c2581cd139b42447d7d9389b889bdaad3a73f1ebb16f2a3237bb19c" +checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.5.0", "errno", "libc", - "linux-raw-sys 0.4.10", - "windows-sys 0.48.0", + "linux-raw-sys 0.4.13", + "windows-sys 0.52.0", ] [[package]] @@ -4842,12 +4949,12 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.7" +version = "0.21.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8" +checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba" dependencies = [ "log", - "ring 0.16.20", + "ring 0.17.8", "rustls-webpki", "sct", ] @@ -4866,49 +4973,49 @@ dependencies = [ [[package]] name = "rustls-pemfile" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", ] [[package]] name = "rustls-webpki" -version = "0.101.6" +version = "0.101.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c7d5dece342910d9ba34d259310cae3e0154b873b35408b787b59bce53d34fe" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" dependencies = [ - "ring 0.16.20", - "untrusted 0.7.1", + "ring 0.17.8", + "untrusted 0.9.0", ] [[package]] name = "rustversion" -version = "1.0.14" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" +checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47" [[package]] name = "ryu" -version = "1.0.15" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" +checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1" [[package]] name = "schannel" -version = "0.1.22" +version = "0.1.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88" +checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "schemars" -version = "0.8.15" +version = "0.8.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c" +checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29" dependencies = [ "dyn-clone", "schemars_derive", @@ -4918,9 +5025,9 @@ dependencies = [ [[package]] name = "schemars_derive" -version = "0.8.15" +version = "0.8.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c" +checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967" dependencies = [ "proc-macro2", "quote", @@ -4951,17 +5058,17 @@ checksum = "1db149f81d46d2deba7cd3c50772474707729550221e69588478ebf9ada425ae" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "sct" -version = "0.7.0" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" dependencies = [ - "ring 0.16.20", - "untrusted 0.7.1", + "ring 0.17.8", + "untrusted 0.9.0", ] [[package]] @@ -4986,7 +5093,7 @@ dependencies = [ "serde_json", "sqlx", "thiserror", - "time 0.3.29", + "time 0.3.35", "tracing", "url", "uuid", @@ -5047,7 +5154,7 @@ dependencies = [ "rust_decimal", "sea-query-derive 0.2.0", "serde_json", - "time 0.3.29", + "time 0.3.35", "uuid", ] @@ -5071,7 +5178,7 @@ dependencies = [ "sea-query 0.27.2", "serde_json", "sqlx", - "time 0.3.29", + "time 0.3.35", "uuid", ] @@ -5154,9 +5261,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" [[package]] name = "security-framework" -version = "2.9.2" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de" +checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6" dependencies = [ "bitflags 1.3.2", "core-foundation", @@ -5167,9 +5274,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.9.1" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a" +checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef" dependencies = [ "core-foundation-sys", "libc", @@ -5177,37 +5284,37 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.19" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0" +checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" [[package]] name = "serde" -version = "1.0.188" +version = "1.0.197" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e" +checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2" dependencies = [ "serde_derive", ] [[package]] name = "serde_bytes" -version = "0.11.12" +version = "0.11.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab33ec92f677585af6d88c65593ae2375adde54efdbf16d597f2cbc7a6d368ff" +checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" dependencies = [ "serde", ] [[package]] name = "serde_derive" -version = "1.0.188" +version = "1.0.197" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" +checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -5223,11 +5330,11 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.107" +version = "1.0.115" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65" +checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "itoa", "ryu", "serde", @@ -5235,9 +5342,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "0.6.4" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80" +checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1" dependencies = [ "serde", ] @@ -5266,20 +5373,20 @@ dependencies = [ [[package]] name = "serde_with" -version = "3.6.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15d167997bd841ec232f5b2b8e0e26606df2e7caa4c31b95ea9ca52b200bd270" +checksum = "ee80b0e361bbf88fd2f6e242ccd19cfda072cb0faa6ae694ecee08199938569a" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "chrono", "hex", "indexmap 1.9.3", - "indexmap 2.0.2", + "indexmap 2.2.6", "serde", "serde_derive", "serde_json", - "serde_with_macros 3.6.1", - "time 0.3.29", + "serde_with_macros 3.7.0", + "time 0.3.35", ] [[package]] @@ -5291,28 +5398,28 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "serde_with_macros" -version = "3.6.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "865f9743393e638991566a8b7a479043c2c8da94a33e0a31f18214c9cae0a64d" +checksum = "6561dc161a9224638a31d876ccdfefbc1df91d3f3a8342eddb35f055d48c7655" dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "serde_yaml" -version = "0.9.25" +version = "0.9.34+deprecated" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a49e178e4452f45cb61d0cd8cebc1b0fafd3e41929e996cef79aa3aca91f574" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "itoa", "ryu", "serde", @@ -5341,7 +5448,7 @@ checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -5458,9 +5565,9 @@ checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a" [[package]] name = "similar" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21" +checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640" [[package]] name = "sized-chunks" @@ -5483,15 +5590,15 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.11.1" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" [[package]] name = "socket2" -version = "0.4.9" +version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662" +checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d" dependencies = [ "libc", "winapi", @@ -5499,12 +5606,12 @@ dependencies = [ [[package]] name = "socket2" -version = "0.5.4" +version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e" +checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -5525,12 +5632,12 @@ dependencies = [ [[package]] name = "solana-account-decoder" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d76c43ef61f527d719b5c6bfa5a62ebba60839739125da9e8a00fb82349afd2" +checksum = "d145d4e1e33bfecd209059a0c4c75d623dbcaeb565b4c197f1815257be45726a" dependencies = [ "Inflector", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bs58 0.4.0", "bv", @@ -5550,9 +5657,9 @@ dependencies = [ [[package]] name = "solana-clap-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb19b9bbd92eee2d8f637026559a9fb48bd98aba534caedf070498a50c91fce8" +checksum = "1deaf83f98be3ba9ecee057efa5cdfa6112267e5b1ff53c4ef4b727f66090b9a" dependencies = [ "chrono", "clap 2.34.0", @@ -5567,16 +5674,16 @@ dependencies = [ [[package]] name = "solana-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9538e3db584a8b1e70060f1f24222b8e0429f18b607f531fb45eb826f4917265" +checksum = "2a8912026a203ff0d90973e7363f141c6ce569484e06ee0a6f72992144263136" dependencies = [ "async-trait", "bincode", "dashmap 4.0.2", "futures", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "indicatif", "log", "quinn", @@ -5600,9 +5707,9 @@ dependencies = [ [[package]] name = "solana-config-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3afd4e309d304e296765cab716fb1fd66c66ec300465c8b26f8cce763275132" +checksum = "4000f4717f86c5f9e1105378e3a6521db770d0ad68417f59960ca4b51103fcd0" dependencies = [ "bincode", "chrono", @@ -5614,15 +5721,15 @@ dependencies = [ [[package]] name = "solana-connection-cache" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92716758e8c0e1c0bc2a5ac2eb3df443a0337fd3991cd38a3b02b12c3fbd18ce" +checksum = "f8b1a4d67c01e5c4464ed9bffb656dec2c88e9bfd7d45bf754f650150e5d81db" dependencies = [ "async-trait", "bincode", "crossbeam-channel", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "log", "rand 0.8.5", "rayon", @@ -5636,9 +5743,9 @@ dependencies = [ [[package]] name = "solana-frozen-abi" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb1b8230474ae9f7c841060c299999124582e8d2a0448d7847720792e98cc64e" +checksum = "1790013c7969353000c22907fc21610adb3389a7c9a27a386ebe7fb32b2ad307" dependencies = [ "ahash 0.8.5", "blake3", @@ -5666,21 +5773,21 @@ dependencies = [ [[package]] name = "solana-frozen-abi-macro" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793910ab733b113b80c357f8f492dda2fabd5671c4ea03db3aa4e46b938fdbe3" +checksum = "a3ed2b49a3dd03ddd5107d6e629e8e5895724227a057b3511bf0c107c6d48308" dependencies = [ "proc-macro2", "quote", "rustc_version", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "solana-logger" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d3f819af39632dc538a566c937253bf46256e4c0e60f621c6db448bc7c76294" +checksum = "bfc0d5b4f046d07e845b69178989a6b3bf168a82eeee006adb77391b339bce64" dependencies = [ "env_logger 0.9.3", "lazy_static", @@ -5689,9 +5796,9 @@ dependencies = [ [[package]] name = "solana-measure" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb045f0235b16f7d926f6e0338db822747d61559a1368c3cb017ba6e02c516d0" +checksum = "857178177c6b378bcfc35df6867a6eef211059f5e4ab01ee87355d6b7493b556" dependencies = [ "log", "solana-sdk", @@ -5699,9 +5806,9 @@ dependencies = [ [[package]] name = "solana-metrics" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1af84362ad5804dc64ca88b1ca5c35bd41321e12d42c798ac06a6fbb60dd0e70" +checksum = "1c68f5cbfbafd002b4d94728748f632a3bd27772ca5c7139710d65940c95477c" dependencies = [ "crossbeam-channel", "gethostname", @@ -5714,9 +5821,9 @@ dependencies = [ [[package]] name = "solana-net-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8e640a95d317cad1322015c5a2b6a71697fd8dabebcb8dd33ed7f5a22869d12" +checksum = "8ce93c50199f077df9d8fd4a82bbdfe654422e1d21e5eecb7f878c4e0078f92f" dependencies = [ "bincode", "clap 3.2.25", @@ -5726,7 +5833,7 @@ dependencies = [ "rand 0.8.5", "serde", "serde_derive", - "socket2 0.5.4", + "socket2 0.5.6", "solana-logger", "solana-sdk", "solana-version", @@ -5736,9 +5843,9 @@ dependencies = [ [[package]] name = "solana-perf" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4266c4bd46620a925b8d508c26578d5559e97fcff6735fd22e39f369c3996ee1" +checksum = "2a233bc2032f4b3f462fe13325cd1a336f355e1d9e793faada488db409cec0d6" dependencies = [ "ahash 0.8.5", "bincode", @@ -5765,17 +5872,17 @@ dependencies = [ [[package]] name = "solana-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "581f38a870bffbe623d900c68579984671f8dfa35bbfb3309d7134de22ce8652" +checksum = "4b2ae4ec9dd6fc76202c94d23942da3cf624325a178e1b0125e70db90b8d7f15" dependencies = [ "ark-bn254", "ark-ec", "ark-ff", "ark-serialize", - "base64 0.21.4", + "base64 0.21.7", "bincode", - "bitflags 2.4.0", + "bitflags 2.5.0", "blake3", "borsh 0.10.3", "borsh 0.9.3", @@ -5786,7 +5893,7 @@ dependencies = [ "console_error_panic_hook", "console_log", "curve25519-dalek", - "getrandom 0.2.10", + "getrandom 0.2.14", "itertools 0.10.5", "js-sys", "lazy_static", @@ -5794,7 +5901,7 @@ dependencies = [ "libsecp256k1", "light-poseidon", "log", - "memoffset 0.9.0", + "memoffset 0.9.1", "num-bigint 0.4.4", "num-derive 0.3.3", "num-traits", @@ -5819,11 +5926,11 @@ dependencies = [ [[package]] name = "solana-program-runtime" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "490b6f65aced077e0c5e57c20f151a134458fc350905c20d7dcf3f2162eaa6f6" +checksum = "b50a6da7b501117f68ef51fc113d771b52af646dc42c43af23a85e32461d59c9" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "bincode", "eager", "enum-iterator", @@ -5847,9 +5954,9 @@ dependencies = [ [[package]] name = "solana-pubsub-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0dc2b26a7a9860f180ce11f69b0ff2a8bea0d4b9e97daee741b1e76565b3c82" +checksum = "bf920143eb7d5bd5f2ea8fc6ab8a1f521512dfe50af7833af40d7cbae83d955d" dependencies = [ "crossbeam-channel", "futures-util", @@ -5872,9 +5979,9 @@ dependencies = [ [[package]] name = "solana-quic-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "727474945d51be37ffe03e7b1d6c9630da41228c7b298a8f45098c203a78ac89" +checksum = "627491c0afd615efb2538c8a49948663ac01aadf99a3cfebb0a63e2b9431ed79" dependencies = [ "async-mutex", "async-trait", @@ -5885,7 +5992,7 @@ dependencies = [ "quinn", "quinn-proto", "rcgen", - "rustls 0.21.7", + "rustls 0.21.10", "solana-connection-cache", "solana-measure", "solana-metrics", @@ -5899,9 +6006,9 @@ dependencies = [ [[package]] name = "solana-rayon-threadlimit" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "853794cccf3bd1984419a594040dfed19666e5a9ad33b0906d4174bc394b22af" +checksum = "4d5c306f32e26031c043c218a0ba3cde08cbb0e08511ab8a4128445d92a535e0" dependencies = [ "lazy_static", "num_cpus", @@ -5909,9 +6016,9 @@ dependencies = [ [[package]] name = "solana-remote-wallet" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b368f270526a5f92ec47c45a6b74ac304b62b08c169b45cf91e0d2f1703889bd" +checksum = "f1c9dbb8cca1b917a01979a1ca98b682f6123df56f11a5227a37c36494ad7740" dependencies = [ "console", "dialoguer", @@ -5928,12 +6035,12 @@ dependencies = [ [[package]] name = "solana-rpc-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71b766876b0c56950ab530d8495ef7eeaeb79e162f03dadaffc0d6852de9e844" +checksum = "2edc8c0f26561e770f28edb9d456221a5554ee90eeb9052ed38942dbb31c035b" dependencies = [ "async-trait", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bs58 0.4.0", "indicatif", @@ -5954,11 +6061,11 @@ dependencies = [ [[package]] name = "solana-rpc-client-api" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "876b2e410cc2403ea3216893f05034b02a180431100eb831d0b67b14fca4d29f" +checksum = "5ff63ab63805a6302ec21284a1138daf5478020f79641d77e53bb84f16c1f5a6" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "bs58 0.4.0", "jsonrpc-core", "reqwest", @@ -5976,9 +6083,9 @@ dependencies = [ [[package]] name = "solana-rpc-client-nonce-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebdb3f02fb3cce3c967f718bc77b79433c24aa801b63dc70f374e8759b2424e4" +checksum = "897db0c1085b8a99ca35871132b6dc6dca3eff68d9210fcd168ccc2e3843dc26" dependencies = [ "clap 2.34.0", "solana-clap-utils", @@ -5989,14 +6096,14 @@ dependencies = [ [[package]] name = "solana-sdk" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d70ab837cc79ed67df6fdb145f1ffd544f1eaa60b0757b750f4864b90498bad" +checksum = "368430d6c9f033e86f8f590d19232d10986d1188c3ad3a6836628d2acc09c21a" dependencies = [ "assert_matches", - "base64 0.21.4", + "base64 0.21.7", "bincode", - "bitflags 2.4.0", + "bitflags 2.5.0", "borsh 0.10.3", "bs58 0.4.0", "bytemuck", @@ -6043,15 +6150,15 @@ dependencies = [ [[package]] name = "solana-sdk-macro" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f9d0433c4084a3260a32ec67f6b4272c4232d15e732be542cd5dfdf0ae1e784" +checksum = "f554d2a144bb0138cfdeced9961cc8a09aaa09f0c3c9a63bd10da41c4a06d420" dependencies = [ "bs58 0.4.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6062,16 +6169,16 @@ checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183" [[package]] name = "solana-streamer" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d70eda40efb5bc57ad50b1ac8452485065c1adae0e701a0348b397db054e2ab5" +checksum = "e28e8941bc0b137f851626ff4d4ce9ebcf9be10619b48d2ed83cd1953af21821" dependencies = [ "async-channel 1.9.0", "bytes", "crossbeam-channel", "futures-util", "histogram", - "indexmap 2.0.2", + "indexmap 2.2.6", "itertools 0.10.5", "libc", "log", @@ -6083,7 +6190,7 @@ dependencies = [ "quinn-proto", "rand 0.8.5", "rcgen", - "rustls 0.21.7", + "rustls 0.21.10", "solana-metrics", "solana-perf", "solana-sdk", @@ -6094,9 +6201,9 @@ dependencies = [ [[package]] name = "solana-thin-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca3c510144695c3d1ee1f84dd9975af7f7d35c168447c484bbd35c21e903c515" +checksum = "760b94e2875b54350f786c85faf50fa1a9a37ae46e9897215d19b373fc2f58cd" dependencies = [ "bincode", "log", @@ -6109,14 +6216,14 @@ dependencies = [ [[package]] name = "solana-tpu-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44f27c8fec609179a7dfc287060df2a926c8cd89329235c4b8d78bd019a72462" +checksum = "7cfdc7ff6cdc1512661de1f9f40723f88dc1e94c8b8938bd537f3713239173e2" dependencies = [ "async-trait", "bincode", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "indicatif", "log", "rayon", @@ -6133,12 +6240,12 @@ dependencies = [ [[package]] name = "solana-transaction-status" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29f58f2f864d900eddf2e21a99ebe445b6be525d597e44952f075d8237035b8e" +checksum = "ba7131d11c8d5a068bfc26a9dc8c9ee0d77eaf60856dd0c8be880542fc5fbbd6" dependencies = [ "Inflector", - "base64 0.21.4", + "base64 0.21.7", "bincode", "borsh 0.10.3", "bs58 0.4.0", @@ -6158,9 +6265,9 @@ dependencies = [ [[package]] name = "solana-udp-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "27ead118c5d549e4345dc59cbc5d9b282164f3e5334707f186e3aa10d40e3b30" +checksum = "54647340d7fa1708c217cbc2411259c5b3784c2df55c1eb4353aca296635ed87" dependencies = [ "async-trait", "solana-connection-cache", @@ -6173,9 +6280,9 @@ dependencies = [ [[package]] name = "solana-version" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "532f5d631562587facc5fe88abd2e31c0d1f29012b6766c664db9f05a39fb05b" +checksum = "1de7a6bad7dff1c595be2eec0c3800a482c6068f3c87c6df87ed091b4e6e642e" dependencies = [ "log", "rustc_version", @@ -6189,9 +6296,9 @@ dependencies = [ [[package]] name = "solana-vote-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c684430058b0a2e733936a8851c8843a3a6316ccd5c969d39411a479d6489642" +checksum = "3c828d118d1f135baacfbf51412c4f1ac18af19fdbee43b002d2908e69cdf50b" dependencies = [ "bincode", "log", @@ -6211,12 +6318,12 @@ dependencies = [ [[package]] name = "solana-zk-token-sdk" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aef1b48d9fdb2619349d2d15942d83c99aabe995ff945d9b418176373aa823c" +checksum = "112944743b08f7e1101368ff6d84745e7b4abb075fabaccc02e01bd3ce4b6d6c" dependencies = [ "aes-gcm-siv", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bytemuck", "byteorder", @@ -6299,7 +6406,7 @@ checksum = "992d9c64c2564cc8f63a4b508bf3ebcdf2254b0429b13cd1d31adb6162432a5f" dependencies = [ "assert_matches", "borsh 0.10.3", - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "solana-program", "spl-token", @@ -6320,9 +6427,9 @@ dependencies = [ [[package]] name = "spl-discriminator" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cce5d563b58ef1bb2cdbbfe0dfb9ffdc24903b10ae6a4df2d8f425ece375033f" +checksum = "daa600f2fe56f32e923261719bae640d873edadbc5237681a39b8e37bfd4d263" dependencies = [ "bytemuck", "solana-program", @@ -6331,25 +6438,25 @@ dependencies = [ [[package]] name = "spl-discriminator-derive" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fadbefec4f3c678215ca72bd71862697bb06b41fd77c0088902dd3203354387b" +checksum = "07fd7858fc4ff8fb0e34090e41d7eb06a823e1057945c26d480bfc21d2338a93" dependencies = [ "quote", "spl-discriminator-syn", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "spl-discriminator-syn" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e5f2044ca42c8938d54d1255ce599c79a1ffd86b677dfab695caa20f9ffc3f2" +checksum = "18fea7be851bd98d10721782ea958097c03a0c2a07d8d4997041d0ece6319a63" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.38", + "syn 2.0.58", "thiserror", ] @@ -6373,11 +6480,11 @@ dependencies = [ [[package]] name = "spl-pod" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2881dddfca792737c0706fa0175345ab282b1b0879c7d877bad129645737c079" +checksum = "85a5db7e4efb1107b0b8e52a13f035437cdcb36ef99c58f6d467f089d9b2915a" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "borsh 0.10.3", "bytemuck", "serde", @@ -6388,11 +6495,11 @@ dependencies = [ [[package]] name = "spl-program-error" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "249e0318493b6bcf27ae9902600566c689b7dfba9f1bdff5893e92253374e78c" +checksum = "7e0657b6490196971d9e729520ba934911ff41fbb2cb9004463dbe23cf8b4b4f" dependencies = [ - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "solana-program", "spl-program-error-derive", @@ -6401,14 +6508,14 @@ dependencies = [ [[package]] name = "spl-program-error-derive" -version = "0.3.1" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab5269c8e868da17b6552ef35a51355a017bd8e0eae269c201fef830d35fa52c" +checksum = "1845dfe71fd68f70382232742e758557afe973ae19e6c06807b2c30f5d5cb474" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6448,7 +6555,7 @@ checksum = "d697fac19fd74ff472dfcc13f0b442dd71403178ce1de7b5d16f83a33561c059" dependencies = [ "arrayref", "bytemuck", - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "num_enum 0.7.2", "solana-program", @@ -6509,9 +6616,9 @@ dependencies = [ [[package]] name = "spl-type-length-value" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a468e6f6371f9c69aae760186ea9f1a01c2908351b06a5e0026d21cfc4d7ecac" +checksum = "8f9ebd75d29c5f48de5f6a9c114e08531030b75b8ac2c557600ac7da0b73b1e8" dependencies = [ "bytemuck", "solana-program", @@ -6522,11 +6629,11 @@ dependencies = [ [[package]] name = "sqlformat" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b7b278788e7be4d0d29c0f39497a0eef3fba6bbc8e70d8bf7fde46edeaa9e85" +checksum = "ce81b7bd7c4493975347ef60d8c7e8b742d4694f4c49f93e0a12ea263938176c" dependencies = [ - "itertools 0.11.0", + "itertools 0.12.1", "nom", "unicode_categories", ] @@ -6547,7 +6654,7 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fa8241483a83a3f33aa5fff7e7d9def398ff9990b2752b6c6112b83c6d246029" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", "atoi", "base64 0.13.1", "bitflags 1.3.2", @@ -6591,7 +6698,7 @@ dependencies = [ "sqlx-rt", "stringprep", "thiserror", - "time 0.3.29", + "time 0.3.35", "tokio-stream", "url", "uuid", @@ -6645,7 +6752,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6bcb902b974bc20b50c3ad3148022a366a46c9a676b587684ff46c237a3329e" dependencies = [ "async-channel 1.9.0", - "async-io", + "async-io 1.13.0", "atomic 0.5.3", "crossbeam-channel", "futures", @@ -6680,6 +6787,12 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + [[package]] name = "subtle" version = "2.4.1" @@ -6699,15 +6812,33 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.38" +version = "2.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b" +checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "syn_derive" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b" +dependencies = [ + "proc-macro-error", + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + [[package]] name = "synstructure" version = "0.12.6" @@ -6749,22 +6880,21 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "tempfile" -version = "3.8.0" +version = "3.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef" +checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" dependencies = [ "cfg-if", - "fastrand 2.0.1", - "redox_syscall 0.3.5", - "rustix 0.38.18", - "windows-sys 0.48.0", + "fastrand 2.0.2", + "rustix 0.38.32", + "windows-sys 0.52.0", ] [[package]] name = "termcolor" -version = "1.3.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" dependencies = [ "winapi-util", ] @@ -6780,35 +6910,35 @@ dependencies = [ [[package]] name = "textwrap" -version = "0.16.0" +version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d" +checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9" [[package]] name = "thiserror" -version = "1.0.49" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4" +checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.49" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc" +checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "thread_local" -version = "1.1.7" +version = "1.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152" +checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" dependencies = [ "cfg-if", "once_cell", @@ -6827,12 +6957,14 @@ dependencies = [ [[package]] name = "time" -version = "0.3.29" +version = "0.3.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "426f806f4089c493dcac0d24c29c01e2c38baf8e30f1b716ee37e83d200b18fe" +checksum = "ef89ece63debf11bc32d1ed8d078ac870cbeb44da02afb02a9ff135ae7ca0582" dependencies = [ "deranged", "itoa", + "num-conv", + "powerfmt", "serde", "time-core", "time-macros", @@ -6846,10 +6978,11 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" [[package]] name = "time-macros" -version = "0.2.15" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ad70d68dba9e1f8aceda7aa6711965dfec1cac869f311a51bd08b3a2ccbce20" +checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" dependencies = [ + "num-conv", "time-core", ] @@ -6889,9 +7022,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.33.0" +version = "1.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653" +checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" dependencies = [ "backtrace", "bytes", @@ -6901,7 +7034,7 @@ dependencies = [ "parking_lot 0.12.1", "pin-project-lite", "signal-hook-registry", - "socket2 0.5.4", + "socket2 0.5.6", "tokio-macros", "tracing", "windows-sys 0.48.0", @@ -6909,13 +7042,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.1.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" +checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6945,15 +7078,15 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ - "rustls 0.21.7", + "rustls 0.21.10", "tokio", ] [[package]] name = "tokio-stream" -version = "0.1.14" +version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842" +checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af" dependencies = [ "futures-core", "pin-project-lite", @@ -6968,18 +7101,18 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" dependencies = [ "futures-util", "log", - "rustls 0.21.7", + "rustls 0.21.10", "tokio", "tokio-rustls 0.24.1", "tungstenite", - "webpki-roots 0.25.2", + "webpki-roots 0.25.4", ] [[package]] name = "tokio-util" -version = "0.7.9" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d" +checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" dependencies = [ "bytes", "futures-core", @@ -7001,14 +7134,14 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.8" +version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35" +checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3" dependencies = [ "serde", "serde_spanned", "toml_datetime", - "toml_edit 0.21.0", + "toml_edit 0.22.9", ] [[package]] @@ -7026,22 +7159,33 @@ version = "0.19.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "toml_datetime", - "winnow", + "winnow 0.5.40", ] [[package]] name = "toml_edit" -version = "0.21.0" +version = "0.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03" +checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", + "toml_datetime", + "winnow 0.5.40", +] + +[[package]] +name = "toml_edit" +version = "0.22.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e40bb779c5187258fd7aad0eb68cb8706a0a81fa712fbea808ab43c4b8374c4" +dependencies = [ + "indexmap 2.2.6", "serde", "serde_spanned", "toml_datetime", - "winnow", + "winnow 0.6.5", ] [[package]] @@ -7087,11 +7231,10 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" [[package]] name = "tracing" -version = "0.1.37" +version = "0.1.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" dependencies = [ - "cfg-if", "log", "pin-project-lite", "tracing-attributes", @@ -7100,20 +7243,20 @@ dependencies = [ [[package]] name = "tracing-attributes" -version = "0.1.26" +version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab" +checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "tracing-core" -version = "0.1.31" +version = "0.1.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a" +checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" dependencies = [ "once_cell", "valuable", @@ -7168,9 +7311,9 @@ dependencies = [ "anchor-client", "anyhow", "bs58 0.4.0", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "flatbuffers", "futures", "hex", @@ -7192,9 +7335,9 @@ dependencies = [ [[package]] name = "triomphe" -version = "0.1.9" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee8098afad3fb0c54a9007aab6804558410503ad676d4633f9c2559a00ac0f" +checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3" dependencies = [ "serde", "stable_deref_trait", @@ -7202,9 +7345,9 @@ dependencies = [ [[package]] name = "try-lock" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" [[package]] name = "tungstenite" @@ -7219,7 +7362,7 @@ dependencies = [ "httparse", "log", "rand 0.8.5", - "rustls 0.21.7", + "rustls 0.21.10", "sha1", "thiserror", "url", @@ -7232,8 +7375,8 @@ name = "txn_forwarder" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.4.8", - "env_logger 0.10.0", + "clap 4.5.4", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -7260,9 +7403,9 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" [[package]] name = "uncased" -version = "0.9.9" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b9bc53168a4be7402ab86c3aad243a84dd7381d09be0eddc81280c1da95ca68" +checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697" dependencies = [ "version_check", ] @@ -7278,9 +7421,9 @@ dependencies = [ [[package]] name = "unicode-bidi" -version = "0.3.13" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" +checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" [[package]] name = "unicode-ident" @@ -7290,18 +7433,18 @@ checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" [[package]] name = "unicode-normalization" -version = "0.1.22" +version = "0.1.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" +checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.10.1" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36" +checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202" [[package]] name = "unicode-width" @@ -7342,9 +7485,9 @@ dependencies = [ [[package]] name = "unsafe-libyaml" -version = "0.2.9" +version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" [[package]] name = "untrusted" @@ -7370,9 +7513,9 @@ dependencies = [ [[package]] name = "url" -version = "2.4.1" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" +checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" dependencies = [ "form_urlencoded", "idna", @@ -7393,11 +7536,11 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" [[package]] name = "uuid" -version = "1.4.1" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d" +checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", "serde", ] @@ -7409,9 +7552,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" [[package]] name = "value-bag" -version = "1.4.2" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a72e1902dde2bd6441347de2b70b7f5d59bf157c6c62f0c44572607a1d55bbe" +checksum = "74797339c3b98616c009c7c3eb53a0ce41e85c8ec66bd3db96ed132d20cfdee8" [[package]] name = "vcpkg" @@ -7476,11 +7619,17 @@ version = "0.11.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" +[[package]] +name = "wasite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" + [[package]] name = "wasm-bindgen" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342" +checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -7488,24 +7637,24 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd" +checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" dependencies = [ "bumpalo", "log", "once_cell", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.37" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03" +checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" dependencies = [ "cfg-if", "js-sys", @@ -7515,9 +7664,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d" +checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -7525,28 +7674,28 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" +checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1" +checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" [[package]] name = "web-sys" -version = "0.3.64" +version = "0.3.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b" +checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" dependencies = [ "js-sys", "wasm-bindgen", @@ -7558,7 +7707,7 @@ version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53" dependencies = [ - "ring 0.17.2", + "ring 0.17.8", "untrusted 0.9.0", ] @@ -7582,9 +7731,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.25.2" +version = "0.25.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" +checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" [[package]] name = "wg" @@ -7599,11 +7748,12 @@ dependencies = [ [[package]] name = "whoami" -version = "1.4.1" +version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22fc3756b8a9133049b26c7f61ab35416c130e8c09b660f5b3958b446f52cc50" +checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9" dependencies = [ - "wasm-bindgen", + "redox_syscall 0.4.1", + "wasite", "web-sys", ] @@ -7639,21 +7789,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] -name = "windows" -version = "0.48.0" +name = "windows-core" +version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", + "windows-targets 0.52.4", ] [[package]] @@ -7666,18 +7807,12 @@ dependencies = [ ] [[package]] -name = "windows-targets" -version = "0.42.2" +name = "windows-sys" +version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", + "windows-targets 0.52.4", ] [[package]] @@ -7696,10 +7831,19 @@ dependencies = [ ] [[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" +name = "windows-targets" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" +checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b" +dependencies = [ + "windows_aarch64_gnullvm 0.52.4", + "windows_aarch64_msvc 0.52.4", + "windows_i686_gnu 0.52.4", + "windows_i686_msvc 0.52.4", + "windows_x86_64_gnu 0.52.4", + "windows_x86_64_gnullvm 0.52.4", + "windows_x86_64_msvc 0.52.4", +] [[package]] name = "windows_aarch64_gnullvm" @@ -7708,10 +7852,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" +name = "windows_aarch64_gnullvm" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" +checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9" [[package]] name = "windows_aarch64_msvc" @@ -7720,10 +7864,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] -name = "windows_i686_gnu" -version = "0.42.2" +name = "windows_aarch64_msvc" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" +checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675" [[package]] name = "windows_i686_gnu" @@ -7732,10 +7876,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] -name = "windows_i686_msvc" -version = "0.42.2" +name = "windows_i686_gnu" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" +checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3" [[package]] name = "windows_i686_msvc" @@ -7744,10 +7888,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" +name = "windows_i686_msvc" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" +checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02" [[package]] name = "windows_x86_64_gnu" @@ -7756,10 +7900,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" +name = "windows_x86_64_gnu" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" +checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03" [[package]] name = "windows_x86_64_gnullvm" @@ -7768,10 +7912,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" +name = "windows_x86_64_gnullvm" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" +checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177" [[package]] name = "windows_x86_64_msvc" @@ -7779,11 +7923,26 @@ version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8" + +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] + [[package]] name = "winnow" -version = "0.5.16" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711d82167854aff2018dfd193aa0fef5370f456732f0d5a0c59b0f1b4b907" +checksum = "dffa400e67ed5a4dd237983829e66475f0a4a26938c4b04c21baede6262215b8" dependencies = [ "memchr", ] @@ -7822,29 +7981,20 @@ dependencies = [ "oid-registry", "rusticata-macros", "thiserror", - "time 0.3.29", + "time 0.3.35", ] [[package]] name = "xxhash-rust" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9828b178da53440fa9c766a3d2f73f7cf5d0ac1fe3980c1e5018d899fd19e07b" - -[[package]] -name = "yaml-rust" -version = "0.4.5" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85" -dependencies = [ - "linked-hash-map", -] +checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03" [[package]] name = "yansi" -version = "1.0.0-rc.1" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1367295b8f788d371ce2dbc842c7b709c73ee1364d30351dd300ec2203b12377" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" [[package]] name = "yasna" @@ -7852,7 +8002,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd" dependencies = [ - "time 0.3.29", + "time 0.3.35", ] [[package]] @@ -7872,7 +8022,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -7892,7 +8042,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -7916,11 +8066,10 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.8+zstd.1.5.5" +version = "2.0.10+zstd.1.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5556e6ee25d32df2586c098bbfa278803692a20d0ab9565e049480d52707ec8c" +checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa" dependencies = [ "cc", - "libc", "pkg-config", ] diff --git a/migration/src/m20230131_140613_change_token_account_indexes.rs b/migration/src/m20230131_140613_change_token_account_indexes.rs index 3d28256cf..49c84eb33 100644 --- a/migration/src/m20230131_140613_change_token_account_indexes.rs +++ b/migration/src/m20230131_140613_change_token_account_indexes.rs @@ -89,3 +89,14 @@ impl MigrationTrait for Migration { Ok(()) } } +<<<<<<< HEAD +======= + +/// Learn more at https://docs.rs/sea-query#iden +#[allow(dead_code)] +#[allow(clippy::upper_case_acronyms)] +#[derive(Iden)] +enum Index { + BRIN, +} +>>>>>>> bb2eb9c (include migration to workspace) From 7a870c2e355c54cf816edae73057cebb6cc03504 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 20 Nov 2023 13:16:22 -0500 Subject: [PATCH 05/21] include das_api to workspace --- .github/workflows/build-api.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.github/workflows/build-api.yml b/.github/workflows/build-api.yml index 8082f52a9..f8e7fd198 100644 --- a/.github/workflows/build-api.yml +++ b/.github/workflows/build-api.yml @@ -46,10 +46,6 @@ jobs: - name: build digital asset rpc infra run: cargo build --verbose --release - - name: build das_api - working-directory: das_api - run: cargo build --verbose --release - - name: rename binaries for ubuntu22 release if: matrix.os == 'ubuntu-22.04' run: | From 7e3f9ef84327471666e48ae931ae621a5cb10ea9 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 20 Nov 2023 13:50:36 -0500 Subject: [PATCH 06/21] add global clippy lints --- Cargo.toml | 2 +- das_api/Cargo.toml | 28 ++++++++++++----- migration/Cargo.toml | 5 +++- .../src/program_transformers/bubblegum/db.rs | 2 +- tools/bgtask_creator/Cargo.toml | 22 ++++++++++++-- tools/load_generation/Cargo.toml | 4 ++- tools/tree-status/Cargo.toml | 30 ++++++++++++++++--- tools/txn_forwarder/Cargo.toml | 8 ++++- 8 files changed, 82 insertions(+), 19 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 769cf02a4..6449d1d48 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,4 +1,5 @@ [workspace] +resolver = "2" members = [ "core", "das_api", @@ -16,7 +17,6 @@ members = [ "tools/tree-status", "tools/txn_forwarder", ] -resolver = "2" [workspace.package] edition = "2021" diff --git a/das_api/Cargo.toml b/das_api/Cargo.toml index 566ac1cd8..d41028193 100644 --- a/das_api/Cargo.toml +++ b/das_api/Cargo.toml @@ -12,25 +12,39 @@ blockbuster = { workspace = true } bs58 = { workspace = true } cadence = { workspace = true } cadence-macros = { workspace = true } -digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } -env_logger = { workspace = true } +digital_asset_types = { workspace = true, features = [ + "json_types", + "sql_types", +] } +env_logger = { workspace = true } figment = { workspace = true, features = ["env"] } hyper = { workspace = true } -jsonrpsee = { workspace = true, features = ["server", "macros"]} -jsonrpsee-core = { workspace = true, features =["server"]} +jsonrpsee = { workspace = true, features = ["server", "macros"] } +jsonrpsee-core = { workspace = true, features = ["server"] } log = { workspace = true } metrics = { workspace = true } mpl-bubblegum = { workspace = true } -mpl-token-metadata = { workspace = true, features = ["serde"] } +mpl-token-metadata = { workspace = true, features = ["serde"] } open-rpc-derive = { workspace = true } open-rpc-schema = { workspace = true } schemars = { workspace = true } schemars_derive = { workspace = true } -sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres"] } +sea-orm = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "sqlx-postgres", +] } serde = { workspace = true } serde_json = { workspace = true } solana-sdk = { workspace = true } -sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } +sqlx = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "postgres", + "uuid", + "offline", + "json", +] } thiserror = { workspace = true } tokio = { workspace = true, features = ["signal"] } tower = { workspace = true } diff --git a/migration/Cargo.toml b/migration/Cargo.toml index c0202ffdd..6ce0612be 100644 --- a/migration/Cargo.toml +++ b/migration/Cargo.toml @@ -9,7 +9,10 @@ publish = { workspace = true } async-std = { workspace = true, features = ["attributes", "tokio1"] } enum-iterator = { workspace = true } enum-iterator-derive = { workspace = true } -sea-orm-migration = { workspace = true, features = ["runtime-tokio-rustls", "sqlx-postgres"] } +sea-orm-migration = { workspace = true, features = [ + "runtime-tokio-rustls", + "sqlx-postgres", +] } [lints] workspace = true diff --git a/nft_ingester/src/program_transformers/bubblegum/db.rs b/nft_ingester/src/program_transformers/bubblegum/db.rs index c562be2be..b7141e231 100644 --- a/nft_ingester/src/program_transformers/bubblegum/db.rs +++ b/nft_ingester/src/program_transformers/bubblegum/db.rs @@ -23,7 +23,7 @@ where Ok(change_log_event.seq) } -fn node_idx_to_leaf_idx(index: i64, tree_height: u32) -> i64 { +const fn node_idx_to_leaf_idx(index: i64, tree_height: u32) -> i64 { index - 2i64.pow(tree_height) } diff --git a/tools/bgtask_creator/Cargo.toml b/tools/bgtask_creator/Cargo.toml index 7011185e5..be662e34e 100644 --- a/tools/bgtask_creator/Cargo.toml +++ b/tools/bgtask_creator/Cargo.toml @@ -8,16 +8,32 @@ publish = { workspace = true } [dependencies] anyhow = { workspace = true } clap = { workspace = true, features = ["derive", "cargo"] } -digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } +digital_asset_types = { workspace = true, features = [ + "json_types", + "sql_types", +] } futures = { workspace = true } lazy_static = { workspace = true } log = { workspace = true } nft_ingester = { workspace = true } prometheus = { workspace = true } -sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"] } +sea-orm = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "sqlx-postgres", + "with-chrono", + "mock", +] } sea-query = { workspace = true, features = ["postgres-array"] } solana-sdk = { workspace = true } -sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } +sqlx = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "postgres", + "uuid", + "offline", + "json", +] } tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } txn_forwarder = { workspace = true } diff --git a/tools/load_generation/Cargo.toml b/tools/load_generation/Cargo.toml index bd7b0de3b..0c7a97d19 100644 --- a/tools/load_generation/Cargo.toml +++ b/tools/load_generation/Cargo.toml @@ -12,7 +12,9 @@ rand = { workspace = true } solana-client = { workspace = true } solana-program = { workspace = true } solana-sdk = { workspace = true } -spl-associated-token-account = { workspace = true, features = ["no-entrypoint"] } +spl-associated-token-account = { workspace = true, features = [ + "no-entrypoint", +] } spl-token = { workspace = true, features = ["no-entrypoint"] } tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } diff --git a/tools/tree-status/Cargo.toml b/tools/tree-status/Cargo.toml index da8ccc058..98e560f23 100644 --- a/tools/tree-status/Cargo.toml +++ b/tools/tree-status/Cargo.toml @@ -12,7 +12,10 @@ anchor-client = { workspace = true } anyhow = { workspace = true } bs58 = { workspace = true } clap = { workspace = true, features = ["derive"] } -digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } +digital_asset_types = { workspace = true, features = [ + "json_types", + "sql_types", +] } env_logger = { workspace = true } flatbuffers = { workspace = true } futures = { workspace = true } @@ -20,16 +23,35 @@ hex = { workspace = true } lazy_static = { workspace = true } log = { workspace = true } prometheus = { workspace = true } -sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"] } +sea-orm = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "sqlx-postgres", + "with-chrono", + "mock", +] } serde_json = { workspace = true } solana-client = { workspace = true } solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } spl-account-compression = { workspace = true, features = ["no-entrypoint"] } spl-noop = { workspace = true, features = ["no-entrypoint"] } -sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } +sqlx = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "postgres", + "uuid", + "offline", + "json", +] } thiserror = { workspace = true } -tokio = { workspace = true, features = ["fs", "macros", "rt-multi-thread", "sync", "time"] } +tokio = { workspace = true, features = [ + "fs", + "macros", + "rt-multi-thread", + "sync", + "time", +] } txn_forwarder = { workspace = true } [lints] diff --git a/tools/txn_forwarder/Cargo.toml b/tools/txn_forwarder/Cargo.toml index c9f5ca999..9a8388325 100644 --- a/tools/txn_forwarder/Cargo.toml +++ b/tools/txn_forwarder/Cargo.toml @@ -23,7 +23,13 @@ solana-client = { workspace = true } solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } thiserror = { workspace = true } -tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync", "time", "fs"] } +tokio = { workspace = true, features = [ + "macros", + "rt-multi-thread", + "sync", + "time", + "fs", +] } tokio-stream = { workspace = true, features = ["io-util"] } [lints] From aa916a4ecd10d0f719edf25b99e5a68bb7a6f18e Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 20 Nov 2023 15:27:59 -0500 Subject: [PATCH 07/21] use workspace --- Cargo.toml | 2 +- digital_asset_types/Cargo.toml | 14 +++++++++++--- ...30131_140613_change_token_account_indexes.rs | 11 ----------- tools/tree-status/Cargo.toml | 17 +++++++++-------- 4 files changed, 21 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6449d1d48..769cf02a4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,4 @@ [workspace] -resolver = "2" members = [ "core", "das_api", @@ -17,6 +16,7 @@ members = [ "tools/tree-status", "tools/txn_forwarder", ] +resolver = "2" [workspace.package] edition = "2021" diff --git a/digital_asset_types/Cargo.toml b/digital_asset_types/Cargo.toml index 449f6e78d..74fb32353 100644 --- a/digital_asset_types/Cargo.toml +++ b/digital_asset_types/Cargo.toml @@ -8,7 +8,7 @@ publish = { workspace = true } [dependencies] async-trait = { workspace = true } blockbuster = { workspace = true } -borsh = { workspace = true, optional = true } +borsh = { workspace = true, optional = true } borsh-derive = { workspace = true, optional = true } bs58 = { workspace = true } futures = { workspace = true } @@ -20,10 +20,18 @@ num-derive = { workspace = true } num-traits = { workspace = true } schemars = { workspace = true } schemars_derive = { workspace = true } -sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"], optional = true } +sea-orm = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "sqlx-postgres", + "with-chrono", + "mock", +], optional = true } sea-query = { workspace = true, features = ["postgres-array"] } serde = { workspace = true, optional = true } -serde_json = { workspace = true, features = ["preserve_order"], optional = true } +serde_json = { workspace = true, features = [ + "preserve_order", +], optional = true } solana-sdk = { workspace = true } spl-concurrent-merkle-tree = { workspace = true } thiserror = { workspace = true } diff --git a/migration/src/m20230131_140613_change_token_account_indexes.rs b/migration/src/m20230131_140613_change_token_account_indexes.rs index 49c84eb33..3d28256cf 100644 --- a/migration/src/m20230131_140613_change_token_account_indexes.rs +++ b/migration/src/m20230131_140613_change_token_account_indexes.rs @@ -89,14 +89,3 @@ impl MigrationTrait for Migration { Ok(()) } } -<<<<<<< HEAD -======= - -/// Learn more at https://docs.rs/sea-query#iden -#[allow(dead_code)] -#[allow(clippy::upper_case_acronyms)] -#[derive(Iden)] -enum Index { - BRIN, -} ->>>>>>> bb2eb9c (include migration to workspace) diff --git a/tools/tree-status/Cargo.toml b/tools/tree-status/Cargo.toml index 98e560f23..3ff2e0c37 100644 --- a/tools/tree-status/Cargo.toml +++ b/tools/tree-status/Cargo.toml @@ -8,6 +8,7 @@ repository = { workspace = true } publish = { workspace = true } [dependencies] + anchor-client = { workspace = true } anyhow = { workspace = true } bs58 = { workspace = true } @@ -36,14 +37,6 @@ solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } spl-account-compression = { workspace = true, features = ["no-entrypoint"] } spl-noop = { workspace = true, features = ["no-entrypoint"] } -sqlx = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "postgres", - "uuid", - "offline", - "json", -] } thiserror = { workspace = true } tokio = { workspace = true, features = [ "fs", @@ -52,6 +45,14 @@ tokio = { workspace = true, features = [ "sync", "time", ] } +sqlx = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "postgres", + "uuid", + "offline", + "json", +] } txn_forwarder = { workspace = true } [lints] From 033873d216c28dda0d26121ab903ee656df5f64c Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Wed, 22 Nov 2023 12:10:23 -0500 Subject: [PATCH 08/21] add crate program_transformers --- .../src/bubblegum/decompress.rs | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 program_transformers/src/bubblegum/decompress.rs diff --git a/program_transformers/src/bubblegum/decompress.rs b/program_transformers/src/bubblegum/decompress.rs new file mode 100644 index 000000000..9db67e8b8 --- /dev/null +++ b/program_transformers/src/bubblegum/decompress.rs @@ -0,0 +1,34 @@ +use { + crate::{ + bubblegum::db::{ + upsert_asset_with_compression_info, upsert_asset_with_leaf_info_for_decompression, + }, + error::ProgramTransformerResult, + }, + blockbuster::{instruction::InstructionBundle, programs::bubblegum::BubblegumInstruction}, + sea_orm::{ConnectionTrait, TransactionTrait}, +}; + +pub async fn decompress<'c, T>( + _parsing_result: &BubblegumInstruction, + bundle: &InstructionBundle<'c>, + txn: &'c T, +) -> ProgramTransformerResult<()> +where + T: ConnectionTrait + TransactionTrait, +{ + let id_bytes = bundle.keys.get(3).unwrap().0.as_slice(); + + // Partial update of asset table with just leaf. + upsert_asset_with_leaf_info_for_decompression(txn, id_bytes.to_vec()).await?; + upsert_asset_with_compression_info( + txn, + id_bytes.to_vec(), + false, + false, + 1, + Some(id_bytes.to_vec()), + true, + ) + .await +} From 1008f862e41841f0193d0060abcb9cfdaadc54a3 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Wed, 22 Nov 2023 22:04:05 -0500 Subject: [PATCH 09/21] nft_ingester: use program_transformers crate --- nft_ingester/Cargo.toml | 1 + nft_ingester/src/error/mod.rs | 50 +- .../src/program_transformers/bubblegum/db.rs | 442 ------------------ .../program_transformers/bubblegum/mint_v1.rs | 364 --------------- nft_ingester/src/program_transformers/mod.rs | 189 -------- .../src/program_transformers/token/mod.rs | 141 ------ .../token_metadata/v1_asset.rs | 393 ---------------- 7 files changed, 7 insertions(+), 1573 deletions(-) delete mode 100644 nft_ingester/src/program_transformers/bubblegum/db.rs delete mode 100644 nft_ingester/src/program_transformers/bubblegum/mint_v1.rs delete mode 100644 nft_ingester/src/program_transformers/mod.rs delete mode 100644 nft_ingester/src/program_transformers/token/mod.rs delete mode 100644 nft_ingester/src/program_transformers/token_metadata/v1_asset.rs diff --git a/nft_ingester/Cargo.toml b/nft_ingester/Cargo.toml index fd17a2bed..db41c0a1f 100644 --- a/nft_ingester/Cargo.toml +++ b/nft_ingester/Cargo.toml @@ -6,6 +6,7 @@ repository = { workspace = true } publish = { workspace = true } [dependencies] + async-trait = { workspace = true } blockbuster = { workspace = true } borsh = { workspace = true } diff --git a/nft_ingester/src/error/mod.rs b/nft_ingester/src/error/mod.rs index 37ed5f24b..ddeae0ba6 100644 --- a/nft_ingester/src/error/mod.rs +++ b/nft_ingester/src/error/mod.rs @@ -1,27 +1,15 @@ -use crate::tasks::TaskData; -use blockbuster::error::BlockbusterError; -use plerkle_messenger::MessengerError; -use plerkle_serialization::error::PlerkleSerializationError; -use sea_orm::{DbErr, TransactionError}; -use thiserror::Error; -use tokio::sync::mpsc::error::SendError; +use { + crate::tasks::TaskData, plerkle_messenger::MessengerError, + plerkle_serialization::error::PlerkleSerializationError, sea_orm::DbErr, + tokio::sync::mpsc::error::SendError, +}; -#[derive(Error, Debug, PartialEq, Eq)] +#[derive(Debug, thiserror::Error)] pub enum IngesterError { - #[error("ChangeLog Event Malformed")] - ChangeLogEventMalformed, - #[error("Compressed Asset Event Malformed")] - CompressedAssetEventMalformed, #[error("Network Error: {0}")] BatchInitNetworkingError(String), - #[error("Error writing batch files")] - BatchInitIOError, - #[error("Storage listener error: ({msg})")] - StorageListenerError { msg: String }, #[error("Storage Write Error: {0}")] StorageWriteError(String), - #[error("NotImplemented")] - NotImplemented, #[error("Deserialization Error: {0}")] DeserializationError(String), #[error("Task Manager Error: {0}")] @@ -36,12 +24,6 @@ pub enum IngesterError { SerializatonError(String), #[error("Messenger error; {0}")] MessengerError(String), - #[error("Blockbuster Parsing error: {0}")] - ParsingError(String), - #[error("Database Error: {0}")] - DatabaseError(String), - #[error("Unknown Task Type: {0}")] - UnknownTaskType(String), #[error("BG Task Manager Not Started")] TaskManagerNotStarted, #[error("Unrecoverable task error: {0}")] @@ -50,8 +32,6 @@ pub enum IngesterError { CacheStorageWriteError(String), #[error("HttpError {status_code}")] HttpError { status_code: String }, - #[error("AssetIndex Error {0}")] - AssetIndexError(String), } impl From for IngesterError { @@ -72,30 +52,12 @@ impl From for IngesterError { } } -impl From for IngesterError { - fn from(err: BlockbusterError) -> Self { - IngesterError::ParsingError(err.to_string()) - } -} - -impl From for IngesterError { - fn from(_err: std::io::Error) -> Self { - IngesterError::BatchInitIOError - } -} - impl From for IngesterError { fn from(e: DbErr) -> Self { IngesterError::StorageWriteError(e.to_string()) } } -impl From> for IngesterError { - fn from(e: TransactionError) -> Self { - IngesterError::StorageWriteError(e.to_string()) - } -} - impl From> for IngesterError { fn from(err: SendError) -> Self { IngesterError::TaskManagerError(format!("Could not create task: {:?}", err.to_string())) diff --git a/nft_ingester/src/program_transformers/bubblegum/db.rs b/nft_ingester/src/program_transformers/bubblegum/db.rs deleted file mode 100644 index b7141e231..000000000 --- a/nft_ingester/src/program_transformers/bubblegum/db.rs +++ /dev/null @@ -1,442 +0,0 @@ -use crate::error::IngesterError; -use digital_asset_types::dao::{ - asset, asset_creators, asset_grouping, backfill_items, cl_audits, cl_items, -}; -use log::{debug, info}; -use mpl_bubblegum::types::Collection; -use sea_orm::{ - query::*, sea_query::OnConflict, ActiveValue::Set, ColumnTrait, DbBackend, EntityTrait, -}; -use spl_account_compression::events::ChangeLogEventV1; - -pub async fn save_changelog_event<'c, T>( - change_log_event: &ChangeLogEventV1, - slot: u64, - txn_id: &str, - txn: &T, - cl_audits: bool, -) -> Result -where - T: ConnectionTrait + TransactionTrait, -{ - insert_change_log(change_log_event, slot, txn_id, txn, cl_audits).await?; - Ok(change_log_event.seq) -} - -const fn node_idx_to_leaf_idx(index: i64, tree_height: u32) -> i64 { - index - 2i64.pow(tree_height) -} - -pub async fn insert_change_log<'c, T>( - change_log_event: &ChangeLogEventV1, - slot: u64, - txn_id: &str, - txn: &T, - cl_audits: bool, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let mut i: i64 = 0; - let depth = change_log_event.path.len() - 1; - let tree_id = change_log_event.id.as_ref(); - for p in change_log_event.path.iter() { - let node_idx = p.index as i64; - debug!( - "seq {}, index {} level {}, node {:?}, txn: {:?}", - change_log_event.seq, - p.index, - i, - bs58::encode(p.node).into_string(), - txn_id, - ); - let leaf_idx = if i == 0 { - Some(node_idx_to_leaf_idx(node_idx, depth as u32)) - } else { - None - }; - - let item = cl_items::ActiveModel { - tree: Set(tree_id.to_vec()), - level: Set(i), - node_idx: Set(node_idx), - hash: Set(p.node.as_ref().to_vec()), - seq: Set(change_log_event.seq as i64), - leaf_idx: Set(leaf_idx), - ..Default::default() - }; - - let audit_item: Option = if cl_audits { - let mut ai: cl_audits::ActiveModel = item.clone().into(); - ai.tx = Set(txn_id.to_string()); - Some(ai) - } else { - None - }; - - i += 1; - let mut query = cl_items::Entity::insert(item) - .on_conflict( - OnConflict::columns([cl_items::Column::Tree, cl_items::Column::NodeIdx]) - .update_columns([ - cl_items::Column::Hash, - cl_items::Column::Seq, - cl_items::Column::LeafIdx, - cl_items::Column::Level, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!("{} WHERE excluded.seq > cl_items.seq", query.sql); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - // Insert the audit item after the insert into cl_items have been completed - if let Some(audit_item) = audit_item { - cl_audits::Entity::insert(audit_item).exec(txn).await?; - } - } - - // If and only if the entire path of nodes was inserted into the `cl_items` table, then insert - // a single row into the `backfill_items` table. This way if an incomplete path was inserted - // into `cl_items` due to an error, a gap will be created for the tree and the backfiller will - // fix it. - if i - 1 == depth as i64 { - // See if the tree already exists in the `backfill_items` table. - let rows = backfill_items::Entity::find() - .filter(backfill_items::Column::Tree.eq(tree_id)) - .limit(1) - .all(txn) - .await?; - - // If the tree does not exist in `backfill_items` and the sequence number is greater than 1, - // then we know we will need to backfill the tree from sequence number 1 up to the current - // sequence number. So in this case we set at flag to force checking the tree. - let force_chk = rows.is_empty() && change_log_event.seq > 1; - - info!("Adding to backfill_items table at level {}", i - 1); - let item = backfill_items::ActiveModel { - tree: Set(tree_id.to_vec()), - seq: Set(change_log_event.seq as i64), - slot: Set(slot as i64), - force_chk: Set(force_chk), - backfilled: Set(false), - failed: Set(false), - ..Default::default() - }; - - backfill_items::Entity::insert(item).exec(txn).await?; - } - - Ok(()) - //TODO -> set maximum size of path and break into multiple statements -} - -#[allow(clippy::too_many_arguments)] -pub async fn upsert_asset_with_leaf_info( - txn: &T, - id: Vec, - nonce: i64, - tree_id: Vec, - leaf: Vec, - data_hash: [u8; 32], - creator_hash: [u8; 32], - seq: i64, - was_decompressed: bool, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let data_hash = bs58::encode(data_hash).into_string().trim().to_string(); - let creator_hash = bs58::encode(creator_hash).into_string().trim().to_string(); - let model = asset::ActiveModel { - id: Set(id), - nonce: Set(Some(nonce)), - tree_id: Set(Some(tree_id)), - leaf: Set(Some(leaf)), - data_hash: Set(Some(data_hash)), - creator_hash: Set(Some(creator_hash)), - leaf_seq: Set(Some(seq)), - ..Default::default() - }; - - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::column(asset::Column::Id) - .update_columns([ - asset::Column::Nonce, - asset::Column::TreeId, - asset::Column::Leaf, - asset::Column::LeafSeq, - asset::Column::DataHash, - asset::Column::CreatorHash, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - - // If we are indexing decompression we will update the leaf regardless of if we have previously - // indexed decompression and regardless of seq. - if !was_decompressed { - query.sql = format!( - "{} WHERE (NOT asset.was_decompressed) AND (excluded.leaf_seq >= asset.leaf_seq OR asset.leaf_seq IS NULL)", - query.sql - ); - } - - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} - -pub async fn upsert_asset_with_leaf_info_for_decompression( - txn: &T, - id: Vec, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let model = asset::ActiveModel { - id: Set(id), - leaf: Set(None), - nonce: Set(Some(0)), - leaf_seq: Set(None), - data_hash: Set(None), - creator_hash: Set(None), - tree_id: Set(None), - seq: Set(Some(0)), - ..Default::default() - }; - let query = asset::Entity::insert(model) - .on_conflict( - OnConflict::column(asset::Column::Id) - .update_columns([ - asset::Column::Leaf, - asset::Column::LeafSeq, - asset::Column::Nonce, - asset::Column::DataHash, - asset::Column::CreatorHash, - asset::Column::TreeId, - asset::Column::Seq, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} - -pub async fn upsert_asset_with_owner_and_delegate_info( - txn: &T, - id: Vec, - owner: Vec, - delegate: Option>, - seq: i64, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let model = asset::ActiveModel { - id: Set(id), - owner: Set(Some(owner)), - delegate: Set(delegate), - owner_delegate_seq: Set(Some(seq)), // gummyroll seq - ..Default::default() - }; - - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::column(asset::Column::Id) - .update_columns([ - asset::Column::Owner, - asset::Column::Delegate, - asset::Column::OwnerDelegateSeq, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.owner_delegate_seq >= asset.owner_delegate_seq OR asset.owner_delegate_seq IS NULL", - query.sql - ); - - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} - -pub async fn upsert_asset_with_compression_info( - txn: &T, - id: Vec, - compressed: bool, - compressible: bool, - supply: i64, - supply_mint: Option>, - was_decompressed: bool, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let model = asset::ActiveModel { - id: Set(id), - compressed: Set(compressed), - compressible: Set(compressible), - supply: Set(supply), - supply_mint: Set(supply_mint), - was_decompressed: Set(was_decompressed), - ..Default::default() - }; - - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::columns([asset::Column::Id]) - .update_columns([ - asset::Column::Compressed, - asset::Column::Compressible, - asset::Column::Supply, - asset::Column::SupplyMint, - asset::Column::WasDecompressed, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!("{} WHERE NOT asset.was_decompressed", query.sql); - txn.execute(query).await?; - - Ok(()) -} - -pub async fn upsert_asset_with_seq(txn: &T, id: Vec, seq: i64) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let model = asset::ActiveModel { - id: Set(id), - seq: Set(Some(seq)), - ..Default::default() - }; - - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::column(asset::Column::Id) - .update_columns([asset::Column::Seq]) - .to_owned(), - ) - .build(DbBackend::Postgres); - - query.sql = format!( - "{} WHERE (NOT asset.was_decompressed) AND (excluded.seq >= asset.seq OR asset.seq IS NULL)", - query.sql - ); - - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} - -pub async fn upsert_creator_verified( - txn: &T, - asset_id: Vec, - creator: Vec, - verified: bool, - seq: i64, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let model = asset_creators::ActiveModel { - asset_id: Set(asset_id), - creator: Set(creator), - verified: Set(verified), - seq: Set(Some(seq)), - ..Default::default() - }; - - let mut query = asset_creators::Entity::insert(model) - .on_conflict( - OnConflict::columns([ - asset_creators::Column::AssetId, - asset_creators::Column::Creator, - ]) - .update_columns([ - asset_creators::Column::Verified, - asset_creators::Column::Seq, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - - query.sql = format!( - "{} WHERE excluded.seq >= asset_creators.seq OR asset_creators.seq is NULL", - query.sql - ); - - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} - -pub async fn upsert_collection_info( - txn: &T, - asset_id: Vec, - collection: Option, - slot_updated: i64, - seq: i64, -) -> Result<(), IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - let (group_value, verified) = match collection { - Some(c) => (Some(c.key.to_string()), c.verified), - None => (None, false), - }; - - let model = asset_grouping::ActiveModel { - asset_id: Set(asset_id), - group_key: Set("collection".to_string()), - group_value: Set(group_value), - verified: Set(Some(verified)), - slot_updated: Set(Some(slot_updated)), - group_info_seq: Set(Some(seq)), - ..Default::default() - }; - - let mut query = asset_grouping::Entity::insert(model) - .on_conflict( - OnConflict::columns([ - asset_grouping::Column::AssetId, - asset_grouping::Column::GroupKey, - ]) - .update_columns([ - asset_grouping::Column::GroupValue, - asset_grouping::Column::Verified, - asset_grouping::Column::SlotUpdated, - asset_grouping::Column::GroupInfoSeq, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - - query.sql = format!( - "{} WHERE excluded.group_info_seq >= asset_grouping.group_info_seq OR asset_grouping.group_info_seq IS NULL", - query.sql - ); - - txn.execute(query) - .await - .map_err(|db_err| IngesterError::StorageWriteError(db_err.to_string()))?; - - Ok(()) -} diff --git a/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs b/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs deleted file mode 100644 index 685649f79..000000000 --- a/nft_ingester/src/program_transformers/bubblegum/mint_v1.rs +++ /dev/null @@ -1,364 +0,0 @@ -use crate::{ - error::IngesterError, - program_transformers::bubblegum::{ - save_changelog_event, upsert_asset_with_compression_info, upsert_asset_with_leaf_info, - upsert_asset_with_owner_and_delegate_info, upsert_asset_with_seq, upsert_collection_info, - }, - tasks::{DownloadMetadata, IntoTaskData, TaskData}, -}; -use blockbuster::{ - instruction::InstructionBundle, - programs::bubblegum::{BubblegumInstruction, LeafSchema, Payload}, - token_metadata::{ - pda::find_master_edition_account, - state::{TokenStandard, UseMethod, Uses}, - }, -}; -use chrono::Utc; -use digital_asset_types::{ - dao::{ - asset, asset_authority, asset_creators, asset_data, asset_v1_account_attachments, - sea_orm_active_enums::{ChainMutability, Mutability, OwnerType, RoyaltyTargetType}, - }, - json::ChainDataV1, -}; -use log::warn; -use num_traits::FromPrimitive; -use sea_orm::{ - entity::*, query::*, sea_query::OnConflict, ConnectionTrait, DbBackend, EntityTrait, JsonValue, -}; -use std::collections::HashSet; - -use digital_asset_types::dao::sea_orm_active_enums::{ - SpecificationAssetClass, SpecificationVersions, V1AccountAttachments, -}; - -// TODO -> consider moving structs into these functions to avoid clone - -pub async fn mint_v1<'c, T>( - parsing_result: &BubblegumInstruction, - bundle: &InstructionBundle<'c>, - txn: &'c T, - cl_audits: bool, -) -> Result, IngesterError> -where - T: ConnectionTrait + TransactionTrait, -{ - if let (Some(le), Some(cl), Some(Payload::MintV1 { args })) = ( - &parsing_result.leaf_update, - &parsing_result.tree_update, - &parsing_result.payload, - ) { - let seq = save_changelog_event(cl, bundle.slot, bundle.txn_id, txn, cl_audits).await?; - let metadata = args; - #[allow(unreachable_patterns)] - return match le.schema { - LeafSchema::V1 { - id, - delegate, - owner, - nonce, - .. - } => { - let (edition_attachment_address, _) = find_master_edition_account(&id); - let id_bytes = id.to_bytes(); - let slot_i = bundle.slot as i64; - let uri = metadata.uri.replace('\0', ""); - let name = metadata.name.clone().into_bytes(); - let symbol = metadata.symbol.clone().into_bytes(); - let mut chain_data = ChainDataV1 { - name: metadata.name.clone(), - symbol: metadata.symbol.clone(), - edition_nonce: metadata.edition_nonce, - primary_sale_happened: metadata.primary_sale_happened, - token_standard: Some(TokenStandard::NonFungible), - uses: metadata.uses.clone().map(|u| Uses { - use_method: UseMethod::from_u8(u.use_method as u8).unwrap(), - remaining: u.remaining, - total: u.total, - }), - }; - chain_data.sanitize(); - let chain_data_json = serde_json::to_value(chain_data) - .map_err(|e| IngesterError::DeserializationError(e.to_string()))?; - let chain_mutability = match metadata.is_mutable { - true => ChainMutability::Mutable, - false => ChainMutability::Immutable, - }; - - let data = asset_data::ActiveModel { - id: Set(id_bytes.to_vec()), - chain_data_mutability: Set(chain_mutability), - chain_data: Set(chain_data_json), - metadata_url: Set(uri.clone()), - metadata: Set(JsonValue::String("processing".to_string())), - metadata_mutability: Set(Mutability::Mutable), - slot_updated: Set(slot_i), - reindex: Set(Some(true)), - raw_name: Set(name.to_vec()), - raw_symbol: Set(symbol.to_vec()), - }; - - let mut query = asset_data::Entity::insert(data) - .on_conflict( - OnConflict::columns([asset_data::Column::Id]) - .update_columns([ - asset_data::Column::ChainDataMutability, - asset_data::Column::ChainData, - asset_data::Column::MetadataUrl, - asset_data::Column::MetadataMutability, - asset_data::Column::SlotUpdated, - asset_data::Column::Reindex, - asset_data::Column::RawName, - asset_data::Column::RawSymbol, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset_data.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - // Insert into `asset` table. - let delegate = if owner == delegate || delegate.to_bytes() == [0; 32] { - None - } else { - Some(delegate.to_bytes().to_vec()) - }; - let tree_id = bundle.keys.get(3).unwrap().0.to_vec(); - - // Set initial mint info. - let asset_model = asset::ActiveModel { - id: Set(id_bytes.to_vec()), - owner_type: Set(OwnerType::Single), - frozen: Set(false), - tree_id: Set(Some(tree_id.clone())), - specification_version: Set(Some(SpecificationVersions::V1)), - specification_asset_class: Set(Some(SpecificationAssetClass::Nft)), - nonce: Set(Some(nonce as i64)), - royalty_target_type: Set(RoyaltyTargetType::Creators), - royalty_target: Set(None), - royalty_amount: Set(metadata.seller_fee_basis_points as i32), //basis points - asset_data: Set(Some(id_bytes.to_vec())), - slot_updated: Set(Some(slot_i)), - ..Default::default() - }; - - // Upsert asset table base info. - let mut query = asset::Entity::insert(asset_model) - .on_conflict( - OnConflict::columns([asset::Column::Id]) - .update_columns([ - asset::Column::OwnerType, - asset::Column::Frozen, - asset::Column::SpecificationVersion, - asset::Column::SpecificationAssetClass, - asset::Column::RoyaltyTargetType, - asset::Column::RoyaltyTarget, - asset::Column::RoyaltyAmount, - asset::Column::AssetData, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - - // Do not overwrite changes that happened after the asset was decompressed. - query.sql = format!( - "{} WHERE excluded.slot_updated > asset.slot_updated OR asset.slot_updated IS NULL", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - - // Partial update of asset table with just compression info elements. - upsert_asset_with_compression_info( - txn, - id_bytes.to_vec(), - true, - false, - 1, - None, - false, - ) - .await?; - - // Partial update of asset table with just leaf. - upsert_asset_with_leaf_info( - txn, - id_bytes.to_vec(), - nonce as i64, - tree_id, - le.leaf_hash.to_vec(), - le.schema.data_hash(), - le.schema.creator_hash(), - seq as i64, - false, - ) - .await?; - - // Partial update of asset table with just leaf owner and delegate. - upsert_asset_with_owner_and_delegate_info( - txn, - id_bytes.to_vec(), - owner.to_bytes().to_vec(), - delegate, - seq as i64, - ) - .await?; - - upsert_asset_with_seq(txn, id_bytes.to_vec(), seq as i64).await?; - - let attachment = asset_v1_account_attachments::ActiveModel { - id: Set(edition_attachment_address.to_bytes().to_vec()), - slot_updated: Set(slot_i), - attachment_type: Set(V1AccountAttachments::MasterEditionV2), - ..Default::default() - }; - - let query = asset_v1_account_attachments::Entity::insert(attachment) - .on_conflict( - OnConflict::columns([asset_v1_account_attachments::Column::Id]) - .do_nothing() - .to_owned(), - ) - .build(DbBackend::Postgres); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - - // Insert into `asset_creators` table. - let creators = &metadata.creators; - if !creators.is_empty() { - // Vec to hold base creator information. - let mut db_creator_infos = Vec::with_capacity(creators.len()); - - // Vec to hold info on whether a creator is verified. This info is protected by `seq` number. - let mut db_creator_verified_infos = Vec::with_capacity(creators.len()); - - // Set to prevent duplicates. - let mut creators_set = HashSet::new(); - - for (i, c) in creators.iter().enumerate() { - if creators_set.contains(&c.address) { - continue; - } - db_creator_infos.push(asset_creators::ActiveModel { - asset_id: Set(id_bytes.to_vec()), - creator: Set(c.address.to_bytes().to_vec()), - position: Set(i as i16), - share: Set(c.share as i32), - slot_updated: Set(Some(slot_i)), - ..Default::default() - }); - - db_creator_verified_infos.push(asset_creators::ActiveModel { - asset_id: Set(id_bytes.to_vec()), - creator: Set(c.address.to_bytes().to_vec()), - verified: Set(c.verified), - seq: Set(Some(seq as i64)), - ..Default::default() - }); - - creators_set.insert(c.address); - } - - // This statement will update base information for each creator. - let query = asset_creators::Entity::insert_many(db_creator_infos) - .on_conflict( - OnConflict::columns([ - asset_creators::Column::AssetId, - asset_creators::Column::Creator, - ]) - .update_columns([ - asset_creators::Column::Position, - asset_creators::Column::Share, - asset_creators::Column::SlotUpdated, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - txn.execute(query).await?; - - // This statement will update whether the creator is verified and the `seq` - // number. `seq` is used to protect the `verified` field, allowing for `mint` - // and `verifyCreator` to be processed out of order. - let mut query = asset_creators::Entity::insert_many(db_creator_verified_infos) - .on_conflict( - OnConflict::columns([ - asset_creators::Column::AssetId, - asset_creators::Column::Creator, - ]) - .update_columns([ - asset_creators::Column::Verified, - asset_creators::Column::Seq, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.seq > asset_creators.seq OR asset_creators.seq IS NULL", - query.sql - ); - txn.execute(query).await?; - } - - // Insert into `asset_authority` table. - let model = asset_authority::ActiveModel { - asset_id: Set(id_bytes.to_vec()), - authority: Set(bundle.keys.get(0).unwrap().0.to_vec()), //TODO - we need to rem,ove the optional bubblegum signer logic - seq: Set(seq as i64), - slot_updated: Set(slot_i), - ..Default::default() - }; - - // Do not attempt to modify any existing values: - // `ON CONFLICT ('asset_id') DO NOTHING`. - let query = asset_authority::Entity::insert(model) - .on_conflict( - OnConflict::columns([asset_authority::Column::AssetId]) - .do_nothing() - .to_owned(), - ) - .build(DbBackend::Postgres); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - - // Upsert into `asset_grouping` table with base collection info. - upsert_collection_info( - txn, - id_bytes.to_vec(), - metadata.collection.clone(), - slot_i, - seq as i64, - ) - .await?; - - if uri.is_empty() { - warn!( - "URI is empty for mint {}. Skipping background task.", - bs58::encode(id).into_string() - ); - return Ok(None); - } - - let mut task = DownloadMetadata { - asset_data_id: id_bytes.to_vec(), - uri: metadata.uri.clone(), - created_at: Some(Utc::now().naive_utc()), - }; - task.sanitize(); - let t = task.into_task_data()?; - Ok(Some(t)) - } - _ => Err(IngesterError::NotImplemented), - }; - } - Err(IngesterError::ParsingError( - "Ix not parsed correctly".to_string(), - )) -} diff --git a/nft_ingester/src/program_transformers/mod.rs b/nft_ingester/src/program_transformers/mod.rs deleted file mode 100644 index fc555829d..000000000 --- a/nft_ingester/src/program_transformers/mod.rs +++ /dev/null @@ -1,189 +0,0 @@ -use crate::{error::IngesterError, tasks::TaskData}; -use blockbuster::{ - instruction::{order_instructions, InstructionBundle, IxPair}, - program_handler::ProgramParser, - programs::{ - bubblegum::BubblegumParser, token_account::TokenAccountParser, - token_metadata::TokenMetadataParser, ProgramParseResult, - }, -}; -use log::{debug, error, info}; -use plerkle_serialization::{AccountInfo, Pubkey as FBPubkey, TransactionInfo}; -use sea_orm::{DatabaseConnection, SqlxPostgresConnector}; -use solana_sdk::pubkey::Pubkey; -use sqlx::PgPool; -use std::collections::{HashMap, HashSet, VecDeque}; -use tokio::sync::mpsc::UnboundedSender; - -use crate::program_transformers::{ - bubblegum::handle_bubblegum_instruction, token::handle_token_program_account, - token_metadata::handle_token_metadata_account, -}; - -mod bubblegum; -mod token; -mod token_metadata; - -pub struct ProgramTransformer { - storage: DatabaseConnection, - task_sender: UnboundedSender, - matchers: HashMap>, - key_set: HashSet, - cl_audits: bool, -} - -impl ProgramTransformer { - pub fn new(pool: PgPool, task_sender: UnboundedSender, cl_audits: bool) -> Self { - let mut matchers: HashMap> = HashMap::with_capacity(1); - let bgum = BubblegumParser {}; - let token_metadata = TokenMetadataParser {}; - let token = TokenAccountParser {}; - matchers.insert(bgum.key(), Box::new(bgum)); - matchers.insert(token_metadata.key(), Box::new(token_metadata)); - matchers.insert(token.key(), Box::new(token)); - let hs = matchers.iter().fold(HashSet::new(), |mut acc, (k, _)| { - acc.insert(*k); - acc - }); - let pool: PgPool = pool; - ProgramTransformer { - storage: SqlxPostgresConnector::from_sqlx_postgres_pool(pool), - task_sender, - matchers, - key_set: hs, - cl_audits, - } - } - - pub fn break_transaction<'i>( - &self, - tx: &'i TransactionInfo<'i>, - ) -> VecDeque<(IxPair<'i>, Option>>)> { - let ref_set: HashSet<&[u8]> = self.key_set.iter().map(|k| k.as_ref()).collect(); - order_instructions(ref_set, tx) - } - - #[allow(clippy::borrowed_box)] - pub fn match_program(&self, key: &FBPubkey) -> Option<&Box> { - self.matchers - .get(&Pubkey::try_from(key.0.as_slice()).expect("valid key from FlatBuffer")) - } - - pub async fn handle_transaction<'a>( - &self, - tx: &'a TransactionInfo<'a>, - ) -> Result<(), IngesterError> { - let sig: Option<&str> = tx.signature(); - info!("Handling Transaction: {:?}", sig); - let instructions = self.break_transaction(tx); - let accounts = tx.account_keys().unwrap_or_default(); - let slot = tx.slot(); - let txn_id = tx.signature().unwrap_or(""); - let mut keys: Vec = Vec::with_capacity(accounts.len()); - for k in accounts.into_iter() { - keys.push(*k); - } - let mut not_impl = 0; - let ixlen = instructions.len(); - debug!("Instructions: {}", ixlen); - let contains = instructions - .iter() - .filter(|(ib, _inner)| ib.0 .0.as_ref() == mpl_bubblegum::ID.as_ref()); - debug!("Instructions bgum: {}", contains.count()); - for (outer_ix, inner_ix) in instructions { - let (program, instruction) = outer_ix; - let ix_accounts = instruction.accounts().unwrap().iter().collect::>(); - let ix_account_len = ix_accounts.len(); - let max = ix_accounts.iter().max().copied().unwrap_or(0) as usize; - if keys.len() < max { - return Err(IngesterError::DeserializationError( - "Missing Accounts in Serialized Ixn/Txn".to_string(), - )); - } - let ix_accounts = - ix_accounts - .iter() - .fold(Vec::with_capacity(ix_account_len), |mut acc, a| { - if let Some(key) = keys.get(*a as usize) { - acc.push(*key); - } - acc - }); - let ix = InstructionBundle { - txn_id, - program, - instruction: Some(instruction), - inner_ix, - keys: ix_accounts.as_slice(), - slot, - }; - - if let Some(program) = self.match_program(&ix.program) { - debug!("Found a ix for program: {:?}", program.key()); - let result = program.handle_instruction(&ix)?; - let concrete = result.result_type(); - match concrete { - ProgramParseResult::Bubblegum(parsing_result) => { - handle_bubblegum_instruction( - parsing_result, - &ix, - &self.storage, - &self.task_sender, - self.cl_audits, - ) - .await - .map_err(|err| { - error!( - "Failed to handle bubblegum instruction for txn {:?}: {:?}", - sig, err - ); - err - })?; - } - _ => { - not_impl += 1; - } - }; - } - } - - if not_impl == ixlen { - debug!("Not imple"); - return Err(IngesterError::NotImplemented); - } - Ok(()) - } - - pub async fn handle_account_update<'b>( - &self, - acct: AccountInfo<'b>, - ) -> Result<(), IngesterError> { - let owner = acct.owner().unwrap(); - if let Some(program) = self.match_program(owner) { - let result = program.handle_account(&acct)?; - let concrete = result.result_type(); - match concrete { - ProgramParseResult::TokenMetadata(parsing_result) => { - handle_token_metadata_account( - &acct, - parsing_result, - &self.storage, - &self.task_sender, - ) - .await - } - ProgramParseResult::TokenProgramAccount(parsing_result) => { - handle_token_program_account( - &acct, - parsing_result, - &self.storage, - &self.task_sender, - ) - .await - } - _ => Err(IngesterError::NotImplemented), - }?; - } - Ok(()) - } -} diff --git a/nft_ingester/src/program_transformers/token/mod.rs b/nft_ingester/src/program_transformers/token/mod.rs deleted file mode 100644 index c32cad020..000000000 --- a/nft_ingester/src/program_transformers/token/mod.rs +++ /dev/null @@ -1,141 +0,0 @@ -use crate::{error::IngesterError, tasks::TaskData}; -use blockbuster::programs::token_account::TokenProgramAccount; -use digital_asset_types::dao::{asset, token_accounts, tokens}; -use plerkle_serialization::AccountInfo; -use sea_orm::{ - entity::*, query::*, sea_query::OnConflict, ActiveValue::Set, ConnectionTrait, - DatabaseConnection, DbBackend, EntityTrait, -}; -use solana_sdk::program_option::COption; -use spl_token::state::AccountState; -use tokio::sync::mpsc::UnboundedSender; - -pub async fn handle_token_program_account<'a, 'b, 'c>( - account_update: &'a AccountInfo<'a>, - parsing_result: &'b TokenProgramAccount, - db: &'c DatabaseConnection, - _task_manager: &UnboundedSender, -) -> Result<(), IngesterError> { - let key = *account_update.pubkey().unwrap(); - let key_bytes = key.0.to_vec(); - let spl_token_program = account_update.owner().unwrap().0.to_vec(); - match &parsing_result { - TokenProgramAccount::TokenAccount(ta) => { - let mint = ta.mint.to_bytes().to_vec(); - let delegate: Option> = match ta.delegate { - COption::Some(d) => Some(d.to_bytes().to_vec()), - COption::None => None, - }; - let frozen = matches!(ta.state, AccountState::Frozen); - let owner = ta.owner.to_bytes().to_vec(); - let model = token_accounts::ActiveModel { - pubkey: Set(key_bytes), - mint: Set(mint.clone()), - delegate: Set(delegate.clone()), - owner: Set(owner.clone()), - frozen: Set(frozen), - delegated_amount: Set(ta.delegated_amount as i64), - token_program: Set(spl_token_program), - slot_updated: Set(account_update.slot() as i64), - amount: Set(ta.amount as i64), - close_authority: Set(None), - }; - - let mut query = token_accounts::Entity::insert(model) - .on_conflict( - OnConflict::columns([token_accounts::Column::Pubkey]) - .update_columns([ - token_accounts::Column::Mint, - token_accounts::Column::DelegatedAmount, - token_accounts::Column::Delegate, - token_accounts::Column::Amount, - token_accounts::Column::Frozen, - token_accounts::Column::TokenProgram, - token_accounts::Column::Owner, - token_accounts::Column::CloseAuthority, - token_accounts::Column::SlotUpdated, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > token_accounts.slot_updated", - query.sql - ); - db.execute(query).await?; - let txn = db.begin().await?; - let asset_update: Option = asset::Entity::find_by_id(mint) - .filter(asset::Column::OwnerType.eq("single")) - .one(&txn) - .await?; - if let Some(asset) = asset_update { - // will only update owner if token account balance is non-zero - if ta.amount > 0 { - let mut active: asset::ActiveModel = asset.into(); - active.owner = Set(Some(owner)); - active.delegate = Set(delegate); - active.frozen = Set(frozen); - active.save(&txn).await?; - } - } - txn.commit().await?; - Ok(()) - } - TokenProgramAccount::Mint(m) => { - let freeze_auth: Option> = match m.freeze_authority { - COption::Some(d) => Some(d.to_bytes().to_vec()), - COption::None => None, - }; - let mint_auth: Option> = match m.mint_authority { - COption::Some(d) => Some(d.to_bytes().to_vec()), - COption::None => None, - }; - let model = tokens::ActiveModel { - mint: Set(key_bytes.clone()), - token_program: Set(spl_token_program), - slot_updated: Set(account_update.slot() as i64), - supply: Set(m.supply as i64), - decimals: Set(m.decimals as i32), - close_authority: Set(None), - extension_data: Set(None), - mint_authority: Set(mint_auth), - freeze_authority: Set(freeze_auth), - }; - - let mut query = tokens::Entity::insert(model) - .on_conflict( - OnConflict::columns([tokens::Column::Mint]) - .update_columns([ - tokens::Column::Supply, - tokens::Column::TokenProgram, - tokens::Column::MintAuthority, - tokens::Column::CloseAuthority, - tokens::Column::ExtensionData, - tokens::Column::SlotUpdated, - tokens::Column::Decimals, - tokens::Column::FreezeAuthority, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > tokens.slot_updated", - query.sql - ); - db.execute(query).await?; - let asset_update: Option = asset::Entity::find_by_id(key_bytes.clone()) - .filter(asset::Column::OwnerType.eq("single")) - .one(db) - .await?; - if let Some(asset) = asset_update { - let mut active: asset::ActiveModel = asset.into(); - active.supply = Set(m.supply as i64); - active.supply_mint = Set(Some(key_bytes)); - active.save(db).await?; - } - Ok(()) - } - _ => Err(IngesterError::NotImplemented), - }?; - Ok(()) -} diff --git a/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs b/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs deleted file mode 100644 index 4f81a4636..000000000 --- a/nft_ingester/src/program_transformers/token_metadata/v1_asset.rs +++ /dev/null @@ -1,393 +0,0 @@ -use crate::{error::IngesterError, tasks::TaskData}; -use blockbuster::token_metadata::{ - pda::find_master_edition_account, - state::{Metadata, TokenStandard, UseMethod, Uses}, -}; -use chrono::Utc; -use digital_asset_types::{ - dao::{ - asset, asset_authority, asset_creators, asset_data, asset_grouping, - asset_v1_account_attachments, - sea_orm_active_enums::{ - ChainMutability, Mutability, OwnerType, RoyaltyTargetType, SpecificationAssetClass, - SpecificationVersions, V1AccountAttachments, - }, - token_accounts, tokens, - }, - json::ChainDataV1, -}; - -use crate::tasks::{DownloadMetadata, IntoTaskData}; -use log::warn; -use num_traits::FromPrimitive; -use plerkle_serialization::Pubkey as FBPubkey; -use sea_orm::{ - entity::*, query::*, sea_query::OnConflict, ActiveValue::Set, ConnectionTrait, DbBackend, - DbErr, EntityTrait, JsonValue, -}; -use std::collections::HashSet; - -pub async fn burn_v1_asset( - conn: &T, - id: FBPubkey, - slot: u64, -) -> Result<(), IngesterError> { - let (id, slot_i) = (id.0, slot as i64); - let model = asset::ActiveModel { - id: Set(id.to_vec()), - slot_updated: Set(Some(slot_i)), - burnt: Set(true), - ..Default::default() - }; - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::columns([asset::Column::Id]) - .update_columns([asset::Column::SlotUpdated, asset::Column::Burnt]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset.slot_updated", - query.sql - ); - conn.execute(query).await?; - Ok(()) -} - -pub async fn save_v1_asset( - conn: &T, - id: FBPubkey, - slot: u64, - metadata: &Metadata, -) -> Result, IngesterError> { - let metadata = metadata.clone(); - let data = metadata.data; - let meta_mint_pubkey = metadata.mint; - let (edition_attachment_address, _) = find_master_edition_account(&meta_mint_pubkey); - let mint = metadata.mint.to_bytes().to_vec(); - let authority = metadata.update_authority.to_bytes().to_vec(); - let id = id.0; - let slot_i = slot as i64; - let uri = data.uri.trim().replace('\0', ""); - let _spec = SpecificationVersions::V1; - let class = match metadata.token_standard { - Some(TokenStandard::NonFungible) => SpecificationAssetClass::Nft, - Some(TokenStandard::FungibleAsset) => SpecificationAssetClass::FungibleAsset, - Some(TokenStandard::Fungible) => SpecificationAssetClass::FungibleToken, - _ => SpecificationAssetClass::Unknown, - }; - let ownership_type = match class { - SpecificationAssetClass::FungibleAsset => OwnerType::Token, - SpecificationAssetClass::FungibleToken => OwnerType::Token, - _ => OwnerType::Single, - }; - - // gets the token and token account for the mint to populate the asset. This is required when the token and token account are indexed, but not the metadata account. If the metadata account is indexed, then the token and ta ingester will update the asset with the correct data - - let (token, token_account): (Option, Option) = - match ownership_type { - OwnerType::Single => { - let token: Option = - tokens::Entity::find_by_id(mint.clone()).one(conn).await?; - // query for token account associated with mint with positive balance - let token_account: Option = token_accounts::Entity::find() - .filter(token_accounts::Column::Mint.eq(mint.clone())) - .filter(token_accounts::Column::Amount.gt(0)) - .one(conn) - .await?; - Ok((token, token_account)) - } - _ => { - let token = tokens::Entity::find_by_id(mint.clone()).one(conn).await?; - Ok((token, None)) - } - } - .map_err(|e: DbErr| IngesterError::DatabaseError(e.to_string()))?; - - // get supply of token, default to 1 since most cases will be NFTs. Token mint ingester will properly set supply if token_result is None - let (supply, supply_mint) = match token { - Some(t) => (Set(t.supply), Set(Some(t.mint))), - None => (Set(1), NotSet), - }; - - // owner and delegate should be from the token account with the mint - let (owner, delegate) = match token_account { - Some(ta) => (Set(Some(ta.owner)), Set(ta.delegate)), - None => (NotSet, NotSet), - }; - - let name = data.name.clone().into_bytes(); - let symbol = data.symbol.clone().into_bytes(); - - let mut chain_data = ChainDataV1 { - name: data.name.clone(), - symbol: data.symbol.clone(), - edition_nonce: metadata.edition_nonce, - primary_sale_happened: metadata.primary_sale_happened, - token_standard: metadata.token_standard, - uses: metadata.uses.map(|u| Uses { - use_method: UseMethod::from_u8(u.use_method as u8).unwrap(), - remaining: u.remaining, - total: u.total, - }), - }; - chain_data.sanitize(); - let chain_data_json = serde_json::to_value(chain_data) - .map_err(|e| IngesterError::DeserializationError(e.to_string()))?; - let chain_mutability = match metadata.is_mutable { - true => ChainMutability::Mutable, - false => ChainMutability::Immutable, - }; - let asset_data_model = asset_data::ActiveModel { - chain_data_mutability: Set(chain_mutability), - chain_data: Set(chain_data_json), - metadata_url: Set(uri.clone()), - metadata: Set(JsonValue::String("processing".to_string())), - metadata_mutability: Set(Mutability::Mutable), - slot_updated: Set(slot_i), - reindex: Set(Some(true)), - id: Set(id.to_vec()), - raw_name: Set(name.to_vec()), - raw_symbol: Set(symbol.to_vec()), - }; - let txn = conn.begin().await?; - let mut query = asset_data::Entity::insert(asset_data_model) - .on_conflict( - OnConflict::columns([asset_data::Column::Id]) - .update_columns([ - asset_data::Column::ChainDataMutability, - asset_data::Column::ChainData, - asset_data::Column::MetadataUrl, - asset_data::Column::MetadataMutability, - asset_data::Column::SlotUpdated, - asset_data::Column::Reindex, - asset_data::Column::RawName, - asset_data::Column::RawSymbol, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset_data.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - let model = asset::ActiveModel { - id: Set(id.to_vec()), - owner, - owner_type: Set(ownership_type), - delegate, - frozen: Set(false), - supply, - supply_mint, - specification_version: Set(Some(SpecificationVersions::V1)), - specification_asset_class: Set(Some(class)), - tree_id: Set(None), - nonce: Set(Some(0)), - seq: Set(Some(0)), - leaf: Set(None), - compressed: Set(false), - compressible: Set(false), - royalty_target_type: Set(RoyaltyTargetType::Creators), - royalty_target: Set(None), - royalty_amount: Set(data.seller_fee_basis_points as i32), //basis points - asset_data: Set(Some(id.to_vec())), - slot_updated: Set(Some(slot_i)), - burnt: Set(false), - ..Default::default() - }; - let mut query = asset::Entity::insert(model) - .on_conflict( - OnConflict::columns([asset::Column::Id]) - .update_columns([ - asset::Column::Owner, - asset::Column::OwnerType, - asset::Column::Delegate, - asset::Column::Frozen, - asset::Column::Supply, - asset::Column::SupplyMint, - asset::Column::SpecificationVersion, - asset::Column::SpecificationAssetClass, - asset::Column::TreeId, - asset::Column::Nonce, - asset::Column::Seq, - asset::Column::Leaf, - asset::Column::Compressed, - asset::Column::Compressible, - asset::Column::RoyaltyTargetType, - asset::Column::RoyaltyTarget, - asset::Column::RoyaltyAmount, - asset::Column::AssetData, - asset::Column::SlotUpdated, - asset::Column::Burnt, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - let attachment = asset_v1_account_attachments::ActiveModel { - id: Set(edition_attachment_address.to_bytes().to_vec()), - slot_updated: Set(slot_i), - attachment_type: Set(V1AccountAttachments::MasterEditionV2), - ..Default::default() - }; - let query = asset_v1_account_attachments::Entity::insert(attachment) - .on_conflict( - OnConflict::columns([asset_v1_account_attachments::Column::Id]) - .do_nothing() - .to_owned(), - ) - .build(DbBackend::Postgres); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - let model = asset_authority::ActiveModel { - asset_id: Set(id.to_vec()), - authority: Set(authority), - seq: Set(0), - slot_updated: Set(slot_i), - ..Default::default() - }; - let mut query = asset_authority::Entity::insert(model) - .on_conflict( - OnConflict::columns([asset_authority::Column::AssetId]) - .update_columns([ - asset_authority::Column::Authority, - asset_authority::Column::Seq, - asset_authority::Column::SlotUpdated, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset_authority.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - if let Some(c) = &metadata.collection { - let model = asset_grouping::ActiveModel { - asset_id: Set(id.to_vec()), - group_key: Set("collection".to_string()), - group_value: Set(Some(c.key.to_string())), - verified: Set(Some(c.verified)), - seq: Set(None), - slot_updated: Set(Some(slot_i)), - ..Default::default() - }; - let mut query = asset_grouping::Entity::insert(model) - .on_conflict( - OnConflict::columns([ - asset_grouping::Column::AssetId, - asset_grouping::Column::GroupKey, - ]) - .update_columns([ - asset_grouping::Column::GroupKey, - asset_grouping::Column::GroupValue, - asset_grouping::Column::Seq, - asset_grouping::Column::SlotUpdated, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset_grouping.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - } - txn.commit().await?; - let creators = data.creators.unwrap_or_default(); - if !creators.is_empty() { - let mut creators_set = HashSet::new(); - let existing_creators: Vec = asset_creators::Entity::find() - .filter( - Condition::all() - .add(asset_creators::Column::AssetId.eq(id.to_vec())) - .add(asset_creators::Column::SlotUpdated.lt(slot_i)), - ) - .all(conn) - .await?; - if !existing_creators.is_empty() { - let mut db_creators = Vec::with_capacity(creators.len()); - for (i, c) in creators.into_iter().enumerate() { - if creators_set.contains(&c.address) { - continue; - } - db_creators.push(asset_creators::ActiveModel { - asset_id: Set(id.to_vec()), - creator: Set(c.address.to_bytes().to_vec()), - share: Set(c.share as i32), - verified: Set(c.verified), - seq: Set(Some(0)), - slot_updated: Set(Some(slot_i)), - position: Set(i as i16), - ..Default::default() - }); - creators_set.insert(c.address); - } - let txn = conn.begin().await?; - asset_creators::Entity::delete_many() - .filter( - Condition::all() - .add(asset_creators::Column::AssetId.eq(id.to_vec())) - .add(asset_creators::Column::SlotUpdated.lt(slot_i)), - ) - .exec(&txn) - .await?; - if !db_creators.is_empty() { - let mut query = asset_creators::Entity::insert_many(db_creators) - .on_conflict( - OnConflict::columns([ - asset_creators::Column::AssetId, - asset_creators::Column::Position, - ]) - .update_columns([ - asset_creators::Column::Creator, - asset_creators::Column::Share, - asset_creators::Column::Verified, - asset_creators::Column::Seq, - asset_creators::Column::SlotUpdated, - ]) - .to_owned(), - ) - .build(DbBackend::Postgres); - query.sql = format!( - "{} WHERE excluded.slot_updated > asset_creators.slot_updated", - query.sql - ); - txn.execute(query) - .await - .map_err(|db_err| IngesterError::AssetIndexError(db_err.to_string()))?; - } - txn.commit().await?; - } - } - if uri.is_empty() { - warn!( - "URI is empty for mint {}. Skipping background task.", - bs58::encode(mint).into_string() - ); - return Ok(None); - } - - let mut task = DownloadMetadata { - asset_data_id: id.to_vec(), - uri, - created_at: Some(Utc::now().naive_utc()), - }; - task.sanitize(); - let t = task.into_task_data()?; - Ok(Some(t)) -} From 83b171eb23a7cab46d007468890f274abd59cab2 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Thu, 23 Nov 2023 11:02:05 -0500 Subject: [PATCH 10/21] remove not used deps --- Cargo.lock | 1690 +++++++++---------- das_api/Cargo.toml | 28 +- digital_asset_types/Cargo.toml | 14 +- digital_asset_types/src/dao/scopes/asset.rs | 10 +- metaplex-rpc-proxy/Cargo.toml | 2 - nft_ingester/Cargo.toml | 1 - nft_ingester/src/backfiller.rs | 2 +- tools/bgtask_creator/Cargo.toml | 22 +- tools/load_generation/Cargo.toml | 4 +- tools/tree-status/Cargo.toml | 31 +- tools/txn_forwarder/Cargo.toml | 8 +- 11 files changed, 792 insertions(+), 1020 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8a5e4dd91..8a629c27a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,8 +18,8 @@ version = "0.7.12" dependencies = [ "anyhow", "bs58 0.4.0", - "clap 4.5.4", - "env_logger 0.10.2", + "clap 4.4.8", + "env_logger 0.10.0", "figment", "flatbuffers", "futures", @@ -93,11 +93,11 @@ dependencies = [ [[package]] name = "ahash" -version = "0.7.8" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" +checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" dependencies = [ - "getrandom 0.2.14", + "getrandom 0.2.10", "once_cell", "version_check", ] @@ -109,7 +109,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cd7d5a2cecb58716e47d67d5703a249964b14c7be1ec3cad3affc295b2d1c35d" dependencies = [ "cfg-if", - "getrandom 0.2.14", + "getrandom 0.2.10", "once_cell", "version_check", "zerocopy", @@ -117,9 +117,9 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" dependencies = [ "memchr", ] @@ -170,7 +170,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7f2a3e1df4685f18d12a943a9f2a7456305401af21a07c9fe076ef9ecd6e400" dependencies = [ "anchor-syn", - "bs58 0.5.1", + "bs58 0.5.0", "proc-macro2", "quote", "syn 1.0.109", @@ -295,7 +295,7 @@ dependencies = [ "bincode", "borsh 0.10.3", "bytemuck", - "getrandom 0.2.14", + "getrandom 0.2.10", "solana-program", "thiserror", ] @@ -307,7 +307,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9101b84702fed2ea57bd22992f75065da5648017135b844283a2f6d74f27825" dependencies = [ "anyhow", - "bs58 0.5.1", + "bs58 0.5.0", "heck 0.3.3", "proc-macro2", "quote", @@ -344,9 +344,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.13" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb" +checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44" dependencies = [ "anstyle", "anstyle-parse", @@ -358,49 +358,49 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.6" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc" +checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87" [[package]] name = "anstyle-parse" -version = "0.2.3" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c" +checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.0.2" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648" +checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] name = "anstyle-wincon" -version = "3.0.2" +version = "3.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7" +checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628" dependencies = [ "anstyle", - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] name = "anyhow" -version = "1.0.82" +version = "1.0.75" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519" +checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" [[package]] name = "arc-swap" -version = "1.7.1" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" +checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6" [[package]] name = "ark-bn254" @@ -550,7 +550,7 @@ dependencies = [ "num-traits", "rusticata-macros", "thiserror", - "time 0.3.35", + "time 0.3.29", ] [[package]] @@ -605,22 +605,22 @@ dependencies = [ [[package]] name = "async-channel" -version = "2.2.0" +version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" +checksum = "d37875bd9915b7d67c2f117ea2c30a0989874d0b2cb694fe25403c85763c0c9e" dependencies = [ "concurrent-queue", - "event-listener 5.3.0", - "event-listener-strategy 0.5.1", + "event-listener 3.1.0", + "event-listener-strategy", "futures-core", "pin-project-lite", ] [[package]] name = "async-compression" -version = "0.4.8" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07dbbf24db18d609b1462965249abdf49129ccad073ec257da372adc83259c60" +checksum = "bb42b2197bf15ccb092b62c74515dbd8b86d0effd934795f6687c93b6e679a2c" dependencies = [ "brotli", "flate2", @@ -632,30 +632,30 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.10.0" +version = "1.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f98c37cf288e302c16ef6c8472aad1e034c6c84ce5ea7b8101c98eb4a802fee" +checksum = "fc5ea910c42e5ab19012bab31f53cb4d63d54c3a27730f9a833a88efcf4bb52d" dependencies = [ - "async-lock 3.3.0", + "async-lock 3.1.1", "async-task", "concurrent-queue", - "fastrand 2.0.2", - "futures-lite 2.3.0", + "fastrand 2.0.1", + "futures-lite 2.0.1", "slab", ] [[package]] name = "async-global-executor" -version = "2.4.1" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" +checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776" dependencies = [ - "async-channel 2.2.0", + "async-channel 1.9.0", "async-executor", - "async-io 2.3.2", - "async-lock 3.3.0", + "async-io", + "async-lock 2.8.0", "blocking", - "futures-lite 2.3.0", + "futures-lite 1.13.0", "once_cell", "tokio", ] @@ -673,32 +673,13 @@ dependencies = [ "futures-lite 1.13.0", "log", "parking", - "polling 2.8.0", + "polling", "rustix 0.37.27", "slab", - "socket2 0.4.10", + "socket2 0.4.9", "waker-fn", ] -[[package]] -name = "async-io" -version = "2.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcccb0f599cfa2f8ace422d3555572f47424da5648a4382a9dd0310ff8210884" -dependencies = [ - "async-lock 3.3.0", - "cfg-if", - "concurrent-queue", - "futures-io", - "futures-lite 2.3.0", - "parking", - "polling 3.6.0", - "rustix 0.38.32", - "slab", - "tracing", - "windows-sys 0.52.0", -] - [[package]] name = "async-lock" version = "2.8.0" @@ -710,12 +691,12 @@ dependencies = [ [[package]] name = "async-lock" -version = "3.3.0" +version = "3.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b" +checksum = "655b9c7fe787d3b25cc0f804a1a8401790f0c5bc395beb5a64dc77d8de079105" dependencies = [ - "event-listener 4.0.3", - "event-listener-strategy 0.4.0", + "event-listener 3.1.0", + "event-listener-strategy", "pin-project-lite", ] @@ -737,7 +718,7 @@ dependencies = [ "async-attributes", "async-channel 1.9.0", "async-global-executor", - "async-io 1.13.0", + "async-io", "async-lock 2.8.0", "crossbeam-utils", "futures-channel", @@ -774,24 +755,24 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "async-task" -version = "4.7.0" +version = "4.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799" +checksum = "b4eb2cdb97421e01129ccb49169d8279ed21e829929144f4a22a6e54ac549ca1" [[package]] name = "async-trait" -version = "0.1.79" +version = "0.1.73" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681" +checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -837,17 +818,17 @@ dependencies = [ [[package]] name = "autocfg" -version = "1.2.0" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" [[package]] name = "backon" -version = "0.4.4" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d67782c3f868daa71d3533538e98a8e13713231969def7536e8039606fc46bf0" +checksum = "0c1a6197b2120bb2185a267f6515038558b019e92b832bb0320e96d66268dcf9" dependencies = [ - "fastrand 2.0.2", + "fastrand 1.9.0", "futures-core", "pin-project", "tokio", @@ -855,9 +836,9 @@ dependencies = [ [[package]] name = "backtrace" -version = "0.3.71" +version = "0.3.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" +checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" dependencies = [ "addr2line", "cc", @@ -895,9 +876,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" [[package]] name = "base64" -version = "0.21.7" +version = "0.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" +checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2" [[package]] name = "base64" @@ -925,7 +906,7 @@ name = "bgtask_creator" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.5.4", + "clap 4.4.8", "digital_asset_types", "futures", "lazy_static", @@ -957,9 +938,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.5.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" +checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635" dependencies = [ "serde", ] @@ -987,9 +968,9 @@ dependencies = [ [[package]] name = "blake3" -version = "1.5.1" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52" +checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87" dependencies = [ "arrayref", "arrayvec", @@ -1060,12 +1041,12 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118" dependencies = [ - "async-channel 2.2.0", - "async-lock 3.3.0", + "async-channel 2.1.0", + "async-lock 3.1.1", "async-task", - "fastrand 2.0.2", + "fastrand 2.0.1", "futures-io", - "futures-lite 2.3.0", + "futures-lite 2.0.1", "piper", "tracing", ] @@ -1090,16 +1071,6 @@ dependencies = [ "hashbrown 0.13.2", ] -[[package]] -name = "borsh" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0901fc8eb0aca4c83be0106d6f2db17d86a08dfc2c25f0e84464bf381158add6" -dependencies = [ - "borsh-derive 1.4.0", - "cfg_aliases", -] - [[package]] name = "borsh-derive" version = "0.9.3" @@ -1126,20 +1097,6 @@ dependencies = [ "syn 1.0.109", ] -[[package]] -name = "borsh-derive" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51670c3aa053938b0ee3bd67c3817e471e626151131b934038e83c5bf8de48f5" -dependencies = [ - "once_cell", - "proc-macro-crate 3.1.0", - "proc-macro2", - "quote", - "syn 2.0.58", - "syn_derive", -] - [[package]] name = "borsh-derive-internal" version = "0.9.3" @@ -1186,9 +1143,9 @@ dependencies = [ [[package]] name = "brotli" -version = "4.0.0" +version = "3.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569" +checksum = "516074a47ef4bce09577a3b379392300159ce5b1ba2e501ff1c819950066100f" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1197,9 +1154,9 @@ dependencies = [ [[package]] name = "brotli-decompressor" -version = "3.0.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525" +checksum = "da74e2b81409b1b743f8f0c62cc6254afefb8b8e50bbfe3735550f7aeefa3448" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1213,18 +1170,18 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3" [[package]] name = "bs58" -version = "0.5.1" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" +checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" dependencies = [ "tinyvec", ] [[package]] name = "bstr" -version = "1.9.1" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706" +checksum = "542f33a8835a0884b006a0c3df3dadd99c0c3f296ed26c2fdc8028e01ad6230c" dependencies = [ "memchr", "serde", @@ -1232,9 +1189,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.16.0" +version = "3.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" +checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" [[package]] name = "bv" @@ -1248,9 +1205,9 @@ dependencies = [ [[package]] name = "bytecheck" -version = "0.6.12" +version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2" +checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627" dependencies = [ "bytecheck_derive", "ptr_meta", @@ -1259,9 +1216,9 @@ dependencies = [ [[package]] name = "bytecheck_derive" -version = "0.6.12" +version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659" +checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61" dependencies = [ "proc-macro2", "quote", @@ -1279,13 +1236,13 @@ dependencies = [ [[package]] name = "bytemuck_derive" -version = "1.6.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60" +checksum = "965ab7eb5f8f97d2a083c799f3a1b994fc397b2fe2da5d1da1626ce15a39f2b1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -1296,9 +1253,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.6.0" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" +checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" [[package]] name = "cadence" @@ -1330,9 +1287,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.0.92" +version = "1.0.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2678b2e3449475e95b0aa6f9b506a28e61b3dc8996592b983695e8ebb58a8b41" +checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" dependencies = [ "jobserver", "libc", @@ -1344,17 +1301,11 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" -[[package]] -name = "cfg_aliases" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" - [[package]] name = "chrono" -version = "0.4.37" +version = "0.4.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e" +checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" dependencies = [ "android-tzdata", "iana-time-zone", @@ -1362,7 +1313,7 @@ dependencies = [ "num-traits", "serde", "wasm-bindgen", - "windows-targets 0.52.4", + "windows-targets 0.48.5", ] [[package]] @@ -1403,29 +1354,29 @@ dependencies = [ "once_cell", "strsim 0.10.0", "termcolor", - "textwrap 0.16.1", + "textwrap 0.16.0", ] [[package]] name = "clap" -version = "4.5.4" +version = "4.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0" +checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64" dependencies = [ "clap_builder", - "clap_derive 4.5.4", + "clap_derive 4.4.7", ] [[package]] name = "clap_builder" -version = "4.5.2" +version = "4.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" +checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc" dependencies = [ "anstream", "anstyle", - "clap_lex 0.7.0", - "strsim 0.11.1", + "clap_lex 0.6.0", + "strsim 0.10.0", ] [[package]] @@ -1443,14 +1394,14 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.4" +version = "4.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64" +checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" dependencies = [ - "heck 0.5.0", + "heck 0.4.1", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -1464,9 +1415,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.7.0" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" +checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" [[package]] name = "colorchoice" @@ -1489,9 +1440,9 @@ dependencies = [ [[package]] name = "combine" -version = "4.6.7" +version = "4.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" +checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" dependencies = [ "bytes", "futures-core", @@ -1503,24 +1454,24 @@ dependencies = [ [[package]] name = "concurrent-queue" -version = "2.4.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363" +checksum = "f057a694a54f12365049b0958a1685bb52d567f5593b355fbf685838e873d400" dependencies = [ "crossbeam-utils", ] [[package]] name = "console" -version = "0.15.8" +version = "0.15.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" +checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8" dependencies = [ "encode_unicode", "lazy_static", "libc", "unicode-width", - "windows-sys 0.52.0", + "windows-sys 0.45.0", ] [[package]] @@ -1557,9 +1508,9 @@ checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" [[package]] name = "core-foundation" -version = "0.9.4" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" dependencies = [ "core-foundation-sys", "libc", @@ -1567,85 +1518,95 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.6" +version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" +checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" [[package]] name = "cpufeatures" -version = "0.2.12" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" +checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1" dependencies = [ "libc", ] [[package]] name = "crc" -version = "3.2.1" +version = "3.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69e6e4d7b33a94f0991c26729976b10ebde1d34c3ee82408fb536164fa10d636" +checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe" dependencies = [ "crc-catalog", ] [[package]] name = "crc-catalog" -version = "2.4.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" +checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484" [[package]] name = "crc32fast" -version = "1.4.0" +version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" +checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" dependencies = [ "cfg-if", ] [[package]] name = "crossbeam-channel" -version = "0.5.12" +version = "0.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95" +checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200" dependencies = [ + "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-deque" -version = "0.8.5" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" +checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef" dependencies = [ + "cfg-if", "crossbeam-epoch", "crossbeam-utils", ] [[package]] name = "crossbeam-epoch" -version = "0.9.18" +version = "0.9.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7" dependencies = [ + "autocfg", + "cfg-if", "crossbeam-utils", + "memoffset 0.9.0", + "scopeguard", ] [[package]] name = "crossbeam-queue" -version = "0.3.11" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35" +checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add" dependencies = [ + "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-utils" -version = "0.8.19" +version = "0.8.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345" +checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" +dependencies = [ + "cfg-if", +] [[package]] name = "crunchy" @@ -1698,9 +1659,9 @@ dependencies = [ [[package]] name = "darling" -version = "0.20.8" +version = "0.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391" +checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e" dependencies = [ "darling_core", "darling_macro", @@ -1708,27 +1669,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.8" +version = "0.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f" +checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim 0.10.0", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "darling_macro" -version = "0.20.8" +version = "0.20.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f" +checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5" dependencies = [ "darling_core", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -1739,7 +1700,7 @@ dependencies = [ "backon", "cadence", "cadence-macros", - "clap 4.5.4", + "clap 4.4.8", "figment", "plerkle_messenger", "solana-account-decoder", @@ -1761,10 +1722,10 @@ dependencies = [ "borsh 0.10.3", "cadence", "cadence-macros", - "clap 4.5.4", + "clap 4.4.8", "das-core", "digital_asset_types", - "env_logger 0.10.2", + "env_logger 0.10.0", "figment", "flatbuffers", "futures", @@ -1794,7 +1755,7 @@ dependencies = [ "cadence", "cadence-macros", "digital_asset_types", - "env_logger 0.10.2", + "env_logger 0.10.0", "figment", "hyper", "jsonrpsee", @@ -1836,17 +1797,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" dependencies = [ "cfg-if", - "hashbrown 0.14.2", + "hashbrown 0.14.1", "lock_api", "once_cell", - "parking_lot_core 0.9.9", + "parking_lot_core 0.9.8", ] [[package]] name = "data-encoding" -version = "2.5.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" +checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308" [[package]] name = "der" @@ -1873,11 +1834,10 @@ dependencies = [ [[package]] name = "deranged" -version = "0.3.11" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" +checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946" dependencies = [ - "powerfmt", "serde", ] @@ -1993,7 +1953,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -2016,7 +1976,7 @@ checksum = "a6cbae11b3de8fce2a456e8ea3dada226b35fe791f0dc1d360c0941f0bb681f3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -2027,9 +1987,9 @@ checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" [[package]] name = "dyn-clone" -version = "1.0.17" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" +checksum = "23d2f3407d9a573d666de4b5bdf10569d73ca9478087346697dcbae6244bfbcd" [[package]] name = "eager" @@ -2074,9 +2034,9 @@ dependencies = [ [[package]] name = "either" -version = "1.10.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" dependencies = [ "serde", ] @@ -2089,31 +2049,31 @@ checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" [[package]] name = "encoding_rs" -version = "0.8.34" +version = "0.8.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" +checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" dependencies = [ "cfg-if", ] [[package]] name = "enum-iterator" -version = "1.5.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fd242f399be1da0a5354aa462d57b4ab2b4ee0683cc552f7c007d2d12d36e94" +checksum = "7add3873b5dd076766ee79c8e406ad1a472c385476b9e38849f8eec24f1be689" dependencies = [ "enum-iterator-derive", ] [[package]] name = "enum-iterator-derive" -version = "1.3.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03cdc46ec28bd728e67540c528013c6a10eb69a02eb31078a1bda695438cbfb8" +checksum = "eecf8589574ce9b895052fa12d69af7a233f99e6107f5cb8dd1044f2a17bfdcb" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -2131,9 +2091,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.10.2" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580" +checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0" dependencies = [ "humantime", "is-terminal", @@ -2150,12 +2110,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "errno" -version = "0.3.8" +version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" +checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] @@ -2166,20 +2126,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" [[package]] name = "event-listener" -version = "4.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e" -dependencies = [ - "concurrent-queue", - "parking", - "pin-project-lite", -] - -[[package]] -name = "event-listener" -version = "5.3.0" +version = "3.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d9944b8ca13534cdfb2800775f8dd4902ff3fc75a50101466decadfdf322a24" +checksum = "d93877bcde0eb80ca09131a08d23f0a5c18a620b01db137dba666d18cd9b30c2" dependencies = [ "concurrent-queue", "parking", @@ -2188,21 +2137,11 @@ dependencies = [ [[package]] name = "event-listener-strategy" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3" -dependencies = [ - "event-listener 4.0.3", - "pin-project-lite", -] - -[[package]] -name = "event-listener-strategy" -version = "0.5.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "332f51cb23d20b0de8458b86580878211da09bcd4503cb579c225b3d124cabb3" +checksum = "d96b852f1345da36d551b9473fa1e2b1eb5c5195585c6c018118bc92a8d91160" dependencies = [ - "event-listener 5.3.0", + "event-listener 3.1.0", "pin-project-lite", ] @@ -2227,9 +2166,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.0.2" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984" +checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" [[package]] name = "feature-probe" @@ -2244,7 +2183,7 @@ dependencies = [ "anyhow", "async-trait", "borsh 0.10.3", - "clap 4.5.4", + "clap 4.4.8", "mpl-bubblegum", "solana-account-decoder", "solana-client", @@ -2255,15 +2194,15 @@ dependencies = [ [[package]] name = "figment" -version = "0.10.16" +version = "0.10.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdefe49ed1057d124dc81a0681c30dd07de56ad96e32adc7b64e8f28eaab31c4" +checksum = "a014ac935975a70ad13a3bff2463b1c1b083b35ae4cb6309cfc59476aa7a181f" dependencies = [ "atomic 0.6.0", "pear", "serde", "serde_yaml", - "toml 0.8.12", + "toml 0.8.8", "uncased", "version_check", ] @@ -2286,9 +2225,9 @@ dependencies = [ [[package]] name = "flate2" -version = "1.0.28" +version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" +checksum = "c6c98ee8095e9d1dcbf2fcc6d95acccb90d1c81db1e44725c6a984b1dbdfb010" dependencies = [ "crc32fast", "miniz_oxide", @@ -2317,9 +2256,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "form_urlencoded" -version = "1.2.1" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" dependencies = [ "percent-encoding", ] @@ -2353,9 +2292,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" +checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40" dependencies = [ "futures-channel", "futures-core", @@ -2368,9 +2307,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" +checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2" dependencies = [ "futures-core", "futures-sink", @@ -2378,15 +2317,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" +checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c" [[package]] name = "futures-executor" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" +checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0" dependencies = [ "futures-core", "futures-task", @@ -2406,9 +2345,9 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" +checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964" [[package]] name = "futures-lite" @@ -2427,45 +2366,46 @@ dependencies = [ [[package]] name = "futures-lite" -version = "2.3.0" +version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5" +checksum = "d3831c2651acb5177cbd83943f3d9c8912c5ad03c76afcc0e9511ba568ec5ebb" dependencies = [ - "fastrand 2.0.2", + "fastrand 2.0.1", "futures-core", "futures-io", + "memchr", "parking", "pin-project-lite", ] [[package]] name = "futures-macro" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" +checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "futures-sink" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" +checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e" [[package]] name = "futures-task" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" +checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65" [[package]] name = "futures-util" -version = "0.3.30" +version = "0.3.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" +checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533" dependencies = [ "futures-channel", "futures-core", @@ -2521,9 +2461,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.14" +version = "0.2.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c" +checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" dependencies = [ "cfg-if", "js-sys", @@ -2534,21 +2474,21 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.1" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" [[package]] name = "globset" -version = "0.4.14" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1" +checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d" dependencies = [ "aho-corasick", "bstr", + "fnv", "log", - "regex-automata 0.4.6", - "regex-syntax 0.8.3", + "regex", ] [[package]] @@ -2576,9 +2516,9 @@ dependencies = [ [[package]] name = "h2" -version = "0.3.26" +version = "0.3.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" +checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833" dependencies = [ "bytes", "fnv", @@ -2586,7 +2526,7 @@ dependencies = [ "futures-sink", "futures-util", "http", - "indexmap 2.2.6", + "indexmap 1.9.3", "slab", "tokio", "tokio-util", @@ -2608,7 +2548,7 @@ version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" dependencies = [ - "ahash 0.7.8", + "ahash 0.7.6", ] [[package]] @@ -2617,7 +2557,7 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ahash 0.7.8", + "ahash 0.7.6", ] [[package]] @@ -2631,9 +2571,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.14.2" +version = "0.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156" +checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12" dependencies = [ "ahash 0.8.5", "allocator-api2", @@ -2645,7 +2585,7 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7" dependencies = [ - "hashbrown 0.14.2", + "hashbrown 0.14.1", ] [[package]] @@ -2683,9 +2623,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.3.9" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" +checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" [[package]] name = "hex" @@ -2701,9 +2641,9 @@ checksum = "12cb882ccb290b8646e554b157ab0b71e64e8d5bef775cd66b6531e52d302669" [[package]] name = "hkdf" -version = "0.12.4" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" +checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437" dependencies = [ "hmac 0.12.1", ] @@ -2740,9 +2680,9 @@ dependencies = [ [[package]] name = "http" -version = "0.2.12" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" dependencies = [ "bytes", "fnv", @@ -2751,9 +2691,9 @@ dependencies = [ [[package]] name = "http-body" -version = "0.4.6" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" +checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" dependencies = [ "bytes", "http", @@ -2786,9 +2726,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.28" +version = "0.14.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" +checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" dependencies = [ "bytes", "futures-channel", @@ -2801,7 +2741,7 @@ dependencies = [ "httpdate", "itoa", "pin-project-lite", - "socket2 0.5.6", + "socket2 0.4.9", "tokio", "tower-service", "tracing", @@ -2810,14 +2750,14 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.24.2" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" +checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97" dependencies = [ "futures-util", "http", "hyper", - "rustls 0.21.10", + "rustls 0.21.7", "tokio", "tokio-rustls 0.24.1", ] @@ -2837,16 +2777,16 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.60" +version = "0.1.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" +checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613" dependencies = [ "android_system_properties", "core-foundation-sys", "iana-time-zone-haiku", "js-sys", "wasm-bindgen", - "windows-core", + "windows", ] [[package]] @@ -2866,9 +2806,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" [[package]] name = "idna" -version = "0.5.0" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" +checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" dependencies = [ "unicode-bidi", "unicode-normalization", @@ -2903,25 +2843,25 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.2.6" +version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" +checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897" dependencies = [ "equivalent", - "hashbrown 0.14.2", + "hashbrown 0.14.1", "serde", ] [[package]] name = "indicatif" -version = "0.17.8" +version = "0.17.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3" +checksum = "fb28741c9db9a713d93deb3bb9515c20788cef5815265bee4980e87bde7e0f25" dependencies = [ "console", "instant", "number_prefix", - "portable-atomic 1.6.0", + "portable-atomic 1.4.3", "unicode-width", ] @@ -2933,15 +2873,16 @@ checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb" [[package]] name = "insta" -version = "1.38.0" +version = "1.35.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc" +checksum = "7c985c1bef99cf13c58fade470483d81a2bfe846ebde60ed28cc2dddec2df9e2" dependencies = [ "console", "lazy_static", "linked-hash-map", "serde", "similar", + "yaml-rust", ] [[package]] @@ -2993,26 +2934,26 @@ version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2" dependencies = [ - "hermit-abi 0.3.9", + "hermit-abi 0.3.3", "libc", "windows-sys 0.48.0", ] [[package]] name = "ipnet" -version = "2.9.0" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" +checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6" [[package]] name = "is-terminal" -version = "0.4.12" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b" +checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b" dependencies = [ - "hermit-abi 0.3.9", - "libc", - "windows-sys 0.52.0", + "hermit-abi 0.3.3", + "rustix 0.38.18", + "windows-sys 0.48.0", ] [[package]] @@ -3026,33 +2967,33 @@ dependencies = [ [[package]] name = "itertools" -version = "0.12.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" dependencies = [ "either", ] [[package]] name = "itoa" -version = "1.0.11" +version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" +checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" [[package]] name = "jobserver" -version = "0.1.28" +version = "0.1.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6" +checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2" dependencies = [ "libc", ] [[package]] name = "js-sys" -version = "0.3.69" +version = "0.3.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" +checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a" dependencies = [ "wasm-bindgen", ] @@ -3173,18 +3114,18 @@ dependencies = [ [[package]] name = "kaigan" -version = "0.2.4" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e623cca1f0e2a0919032c1bdabbf81dd9aa34658d5066aca7bb90d608317ab91" +checksum = "4a26f49495f94a283312e7ef45a243540ef20c9356bb01c8d84a61ac8ba5339b" dependencies = [ "borsh 0.10.3", ] [[package]] name = "keccak" -version = "0.1.5" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" +checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" dependencies = [ "cpufeatures", ] @@ -3206,19 +3147,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.153" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" - -[[package]] -name = "libredox" -version = "0.1.3" +version = "0.2.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" -dependencies = [ - "bitflags 2.5.0", - "libc", -] +checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b" [[package]] name = "libsecp256k1" @@ -3294,9 +3225,9 @@ checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519" [[package]] name = "linux-raw-sys" -version = "0.4.13" +version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c" +checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f" [[package]] name = "load_generation" @@ -3315,9 +3246,9 @@ dependencies = [ [[package]] name = "lock_api" -version = "0.4.11" +version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" +checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16" dependencies = [ "autocfg", "scopeguard", @@ -3325,9 +3256,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.21" +version = "0.4.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" +checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" dependencies = [ "value-bag", ] @@ -3353,9 +3284,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.7.2" +version = "2.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" +checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" [[package]] name = "memmap2" @@ -3377,9 +3308,9 @@ dependencies = [ [[package]] name = "memoffset" -version = "0.9.1" +version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c" dependencies = [ "autocfg", ] @@ -3404,8 +3335,6 @@ dependencies = [ "log", "proxy-wasm", "regex", - "wasi 0.7.0", - "wasm-bindgen", ] [[package]] @@ -3414,7 +3343,7 @@ version = "0.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b9b8653cec6897f73b519a43fba5ee3d50f62fe9af80b428accdcc093b4a849" dependencies = [ - "ahash 0.7.8", + "ahash 0.7.6", "metrics-macros", "portable-atomic 0.3.20", ] @@ -3464,18 +3393,18 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" [[package]] name = "miniz_oxide" -version = "0.7.2" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" +checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" dependencies = [ "adler", ] [[package]] name = "mio" -version = "0.8.11" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" +checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2" dependencies = [ "libc", "wasi 0.11.0+wasi-snapshot-preview1", @@ -3507,22 +3436,22 @@ dependencies = [ "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.7.0", + "serde_with 3.6.1", "solana-program", "thiserror", ] [[package]] name = "mpl-token-metadata" -version = "4.1.2" +version = "4.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "caf0f61b553e424a6234af1268456972ee66c2222e1da89079242251fa7479e5" +checksum = "b4b2de608098eb2ef2a5392069dea83084967e25a4d69d0380a6bb02454fc0fe" dependencies = [ "borsh 0.10.3", "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.7.0", + "serde_with 3.6.1", "solana-program", "thiserror", ] @@ -3550,13 +3479,12 @@ name = "nft_ingester" version = "0.7.2" dependencies = [ "async-trait", - "blockbuster", "borsh 0.10.3", "bs58 0.4.0", "cadence", "cadence-macros", "chrono", - "clap 4.5.4", + "clap 4.4.8", "digital_asset_types", "figment", "flatbuffers", @@ -3664,12 +3592,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "num-conv" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" - [[package]] name = "num-derive" version = "0.3.3" @@ -3683,29 +3605,30 @@ dependencies = [ [[package]] name = "num-derive" -version = "0.4.2" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +checksum = "cfb77679af88f8b125209d354a202862602672222e7f2313fdd6dc349bad4712" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "num-integer" -version = "0.1.46" +version = "0.1.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" dependencies = [ + "autocfg", "num-traits", ] [[package]] name = "num-iter" -version = "0.1.44" +version = "0.1.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9" +checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" dependencies = [ "autocfg", "num-integer", @@ -3726,9 +3649,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.18" +version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a" +checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" dependencies = [ "autocfg", ] @@ -3739,7 +3662,7 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi 0.3.9", + "hermit-abi 0.3.3", "libc", ] @@ -3770,7 +3693,7 @@ dependencies = [ "proc-macro-crate 1.3.1", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -3779,10 +3702,10 @@ version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b" dependencies = [ - "proc-macro-crate 3.1.0", + "proc-macro-crate 1.3.1", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -3793,9 +3716,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" [[package]] name = "object" -version = "0.32.2" +version = "0.32.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" +checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" dependencies = [ "memchr", ] @@ -3817,9 +3740,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "opaque-debug" -version = "0.3.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" +checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" [[package]] name = "open-rpc-derive" @@ -3847,11 +3770,11 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.64" +version = "0.10.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" +checksum = "bac25ee399abb46215765b1cb35bc0212377e58a061560d8b29b024fd0430e7c" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.4.0", "cfg-if", "foreign-types", "libc", @@ -3868,7 +3791,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -3879,9 +3802,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.102" +version = "0.9.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2" +checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d" dependencies = [ "cc", "libc", @@ -3948,7 +3871,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" dependencies = [ "lock_api", - "parking_lot_core 0.9.9", + "parking_lot_core 0.9.8", ] [[package]] @@ -3967,13 +3890,13 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.9" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" +checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.4.1", + "redox_syscall 0.3.5", "smallvec", "windows-targets 0.48.5", ] @@ -4004,9 +3927,9 @@ dependencies = [ [[package]] name = "pear" -version = "0.2.9" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467" +checksum = "61a386cd715229d399604b50d1361683fe687066f42d56f54be995bc6868f71c" dependencies = [ "inlinable_string", "pear_codegen", @@ -4015,14 +3938,14 @@ dependencies = [ [[package]] name = "pear_codegen" -version = "0.2.9" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147" +checksum = "da9f0f13dac8069c139e8300a6510e3f4143ecf5259c60b116a9b271b4ca0d54" dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -4036,9 +3959,9 @@ dependencies = [ [[package]] name = "percent-encoding" -version = "2.3.1" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" +checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" [[package]] name = "percentage" @@ -4051,29 +3974,29 @@ dependencies = [ [[package]] name = "pin-project" -version = "1.1.5" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" +checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.1.5" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" +checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "pin-project-lite" -version = "0.2.14" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" +checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" [[package]] name = "pin-utils" @@ -4088,7 +4011,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4" dependencies = [ "atomic-waker", - "fastrand 2.0.2", + "fastrand 2.0.1", "futures-io", ] @@ -4105,9 +4028,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.30" +version = "0.3.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" [[package]] name = "plain" @@ -4117,9 +4040,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" [[package]] name = "plerkle_messenger" -version = "1.8.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a94c75e3178528c45bca0b7d515bdc6a3733b5f67d5b37b8a085cf6d7f81e3f2" +checksum = "e2f8e4e8975dcd2dbf94c7f84409096f0a0e5af287eabc9a212704e9e325ec84" dependencies = [ "async-mutex", "async-trait", @@ -4165,21 +4088,6 @@ dependencies = [ "windows-sys 0.48.0", ] -[[package]] -name = "polling" -version = "3.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0c976a60b2d7e99d6f229e414670a9b85d13ac305cc6d1e9c134de58c5aaaf6" -dependencies = [ - "cfg-if", - "concurrent-queue", - "hermit-abi 0.3.9", - "pin-project-lite", - "rustix 0.38.32", - "tracing", - "windows-sys 0.52.0", -] - [[package]] name = "polyval" version = "0.5.3" @@ -4198,20 +4106,14 @@ version = "0.3.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e30165d31df606f5726b090ec7592c308a0eaf61721ff64c9a3018e344a8753e" dependencies = [ - "portable-atomic 1.6.0", + "portable-atomic 1.4.3", ] [[package]] name = "portable-atomic" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0" - -[[package]] -name = "powerfmt" -version = "0.2.0" +version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" +checksum = "31114a898e107c51bb1609ffaf55a0e011cf6a4d7f1170d0015a165082c0338b" [[package]] name = "ppv-lite86" @@ -4238,15 +4140,6 @@ dependencies = [ "toml_edit 0.19.15", ] -[[package]] -name = "proc-macro-crate" -version = "3.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284" -dependencies = [ - "toml_edit 0.21.1", -] - [[package]] name = "proc-macro-error" version = "1.0.4" @@ -4273,9 +4166,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.79" +version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" +checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" dependencies = [ "unicode-ident", ] @@ -4288,7 +4181,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", "version_check", "yansi", ] @@ -4386,7 +4279,7 @@ checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -4400,7 +4293,7 @@ dependencies = [ "quinn-proto", "quinn-udp", "rustc-hash", - "rustls 0.21.10", + "rustls 0.21.7", "thiserror", "tokio", "tracing", @@ -4416,7 +4309,7 @@ dependencies = [ "rand 0.8.5", "ring 0.16.20", "rustc-hash", - "rustls 0.21.10", + "rustls 0.21.7", "rustls-native-certs", "slab", "thiserror", @@ -4432,16 +4325,16 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7" dependencies = [ "bytes", "libc", - "socket2 0.5.6", + "socket2 0.5.4", "tracing", "windows-sys 0.48.0", ] [[package]] name = "quote" -version = "1.0.36" +version = "1.0.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" dependencies = [ "proc-macro2", ] @@ -4549,7 +4442,7 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.14", + "getrandom 0.2.10", ] [[package]] @@ -4572,9 +4465,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.10.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" +checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" dependencies = [ "either", "rayon-core", @@ -4582,9 +4475,9 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.12.1" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" +checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" dependencies = [ "crossbeam-deque", "crossbeam-utils", @@ -4598,7 +4491,7 @@ checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b" dependencies = [ "pem", "ring 0.16.20", - "time 0.3.35", + "time 0.3.29", "yasna", ] @@ -4620,7 +4513,7 @@ dependencies = [ "arc-swap", "async-trait", "bytes", - "combine 4.6.7", + "combine 4.6.6", "futures", "futures-util", "itoa", @@ -4646,34 +4539,34 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.4.1" +version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" +checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" dependencies = [ "bitflags 1.3.2", ] [[package]] name = "redox_users" -version = "0.4.5" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891" +checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" dependencies = [ - "getrandom 0.2.14", - "libredox", + "getrandom 0.2.10", + "redox_syscall 0.2.16", "thiserror", ] [[package]] name = "regex" -version = "1.10.4" +version = "1.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" +checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.4.6", - "regex-syntax 0.8.3", + "regex-automata 0.3.9", + "regex-syntax 0.7.5", ] [[package]] @@ -4687,13 +4580,13 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.6" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" +checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.8.3", + "regex-syntax 0.7.5", ] [[package]] @@ -4704,27 +4597,27 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.8.3" +version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" +checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" [[package]] name = "rend" -version = "0.4.2" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c" +checksum = "a2571463863a6bd50c32f94402933f03457a3fbaf697a707c5be741e459f08fd" dependencies = [ "bytecheck", ] [[package]] name = "reqwest" -version = "0.11.27" +version = "0.11.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" +checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b" dependencies = [ "async-compression", - "base64 0.21.7", + "base64 0.21.4", "bytes", "encoding_rs", "futures-core", @@ -4743,12 +4636,11 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls 0.21.10", + "rustls 0.21.7", "rustls-pemfile", "serde", "serde_json", "serde_urlencoded", - "sync_wrapper", "system-configuration", "tokio", "tokio-native-tls", @@ -4759,7 +4651,7 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "webpki-roots 0.25.4", + "webpki-roots 0.25.2", "winreg", ] @@ -4780,28 +4672,26 @@ dependencies = [ [[package]] name = "ring" -version = "0.17.8" +version = "0.17.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" +checksum = "911b295d2d302948838c8ac142da1ee09fa7863163b44e6715bc9357905878b8" dependencies = [ "cc", - "cfg-if", - "getrandom 0.2.14", + "getrandom 0.2.10", "libc", "spin 0.9.8", "untrusted 0.9.0", - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] name = "rkyv" -version = "0.7.44" +version = "0.7.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0" +checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58" dependencies = [ "bitvec", "bytecheck", - "bytes", "hashbrown 0.12.3", "ptr_meta", "rend", @@ -4813,9 +4703,9 @@ dependencies = [ [[package]] name = "rkyv_derive" -version = "0.7.44" +version = "0.7.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65" +checksum = "b2e06b915b5c230a17d7a736d1e2e63ee753c256a8614ef3f5147b13a4f5541d" dependencies = [ "proc-macro2", "quote", @@ -4858,12 +4748,12 @@ dependencies = [ [[package]] name = "rust_decimal" -version = "1.35.0" +version = "1.32.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1790d1c4c0ca81211399e0e0af16333276f375209e71a37b67698a373db5b47a" +checksum = "a4c4216490d5a413bc6d10fa4742bd7d4955941d062c0ef873141d6b0e7b30fd" dependencies = [ "arrayvec", - "borsh 1.4.0", + "borsh 0.10.3", "bytes", "num-traits", "rand 0.8.5", @@ -4886,9 +4776,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-serialize" -version = "0.3.25" +version = "0.3.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe834bc780604f4674073badbad26d7219cadfb4a2275802db12cbae17498401" +checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda" [[package]] name = "rustc_version" @@ -4924,15 +4814,15 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.32" +version = "0.38.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" +checksum = "5a74ee2d7c2581cd139b42447d7d9389b889bdaad3a73f1ebb16f2a3237bb19c" dependencies = [ - "bitflags 2.5.0", + "bitflags 2.4.0", "errno", "libc", - "linux-raw-sys 0.4.13", - "windows-sys 0.52.0", + "linux-raw-sys 0.4.10", + "windows-sys 0.48.0", ] [[package]] @@ -4949,12 +4839,12 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.10" +version = "0.21.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba" +checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8" dependencies = [ "log", - "ring 0.17.8", + "ring 0.16.20", "rustls-webpki", "sct", ] @@ -4973,49 +4863,49 @@ dependencies = [ [[package]] name = "rustls-pemfile" -version = "1.0.4" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" +checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2" dependencies = [ - "base64 0.21.7", + "base64 0.21.4", ] [[package]] name = "rustls-webpki" -version = "0.101.7" +version = "0.101.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" +checksum = "3c7d5dece342910d9ba34d259310cae3e0154b873b35408b787b59bce53d34fe" dependencies = [ - "ring 0.17.8", - "untrusted 0.9.0", + "ring 0.16.20", + "untrusted 0.7.1", ] [[package]] name = "rustversion" -version = "1.0.15" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47" +checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" [[package]] name = "ryu" -version = "1.0.17" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1" +checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" [[package]] name = "schannel" -version = "0.1.23" +version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" +checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] name = "schemars" -version = "0.8.16" +version = "0.8.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29" +checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c" dependencies = [ "dyn-clone", "schemars_derive", @@ -5025,9 +4915,9 @@ dependencies = [ [[package]] name = "schemars_derive" -version = "0.8.16" +version = "0.8.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967" +checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c" dependencies = [ "proc-macro2", "quote", @@ -5058,17 +4948,17 @@ checksum = "1db149f81d46d2deba7cd3c50772474707729550221e69588478ebf9ada425ae" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "sct" -version = "0.7.1" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" +checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" dependencies = [ - "ring 0.17.8", - "untrusted 0.9.0", + "ring 0.16.20", + "untrusted 0.7.1", ] [[package]] @@ -5093,7 +4983,7 @@ dependencies = [ "serde_json", "sqlx", "thiserror", - "time 0.3.35", + "time 0.3.29", "tracing", "url", "uuid", @@ -5154,7 +5044,7 @@ dependencies = [ "rust_decimal", "sea-query-derive 0.2.0", "serde_json", - "time 0.3.35", + "time 0.3.29", "uuid", ] @@ -5178,7 +5068,7 @@ dependencies = [ "sea-query 0.27.2", "serde_json", "sqlx", - "time 0.3.35", + "time 0.3.29", "uuid", ] @@ -5261,9 +5151,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" [[package]] name = "security-framework" -version = "2.10.0" +version = "2.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6" +checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de" dependencies = [ "bitflags 1.3.2", "core-foundation", @@ -5274,9 +5164,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.10.0" +version = "2.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef" +checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a" dependencies = [ "core-foundation-sys", "libc", @@ -5284,37 +5174,37 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.22" +version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" +checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0" [[package]] name = "serde" -version = "1.0.197" +version = "1.0.188" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2" +checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e" dependencies = [ "serde_derive", ] [[package]] name = "serde_bytes" -version = "0.11.14" +version = "0.11.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" +checksum = "ab33ec92f677585af6d88c65593ae2375adde54efdbf16d597f2cbc7a6d368ff" dependencies = [ "serde", ] [[package]] name = "serde_derive" -version = "1.0.197" +version = "1.0.188" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" +checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -5330,11 +5220,11 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.115" +version = "1.0.107" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd" +checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65" dependencies = [ - "indexmap 2.2.6", + "indexmap 2.0.2", "itoa", "ryu", "serde", @@ -5342,9 +5232,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "0.6.5" +version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1" +checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80" dependencies = [ "serde", ] @@ -5373,20 +5263,20 @@ dependencies = [ [[package]] name = "serde_with" -version = "3.7.0" +version = "3.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee80b0e361bbf88fd2f6e242ccd19cfda072cb0faa6ae694ecee08199938569a" +checksum = "15d167997bd841ec232f5b2b8e0e26606df2e7caa4c31b95ea9ca52b200bd270" dependencies = [ - "base64 0.21.7", + "base64 0.21.4", "chrono", "hex", "indexmap 1.9.3", - "indexmap 2.2.6", + "indexmap 2.0.2", "serde", "serde_derive", "serde_json", - "serde_with_macros 3.7.0", - "time 0.3.35", + "serde_with_macros 3.6.1", + "time 0.3.29", ] [[package]] @@ -5398,28 +5288,28 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "serde_with_macros" -version = "3.7.0" +version = "3.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6561dc161a9224638a31d876ccdfefbc1df91d3f3a8342eddb35f055d48c7655" +checksum = "865f9743393e638991566a8b7a479043c2c8da94a33e0a31f18214c9cae0a64d" dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "serde_yaml" -version = "0.9.34+deprecated" +version = "0.9.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" +checksum = "1a49e178e4452f45cb61d0cd8cebc1b0fafd3e41929e996cef79aa3aca91f574" dependencies = [ - "indexmap 2.2.6", + "indexmap 2.0.2", "itoa", "ryu", "serde", @@ -5448,7 +5338,7 @@ checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -5565,9 +5455,9 @@ checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a" [[package]] name = "similar" -version = "2.5.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640" +checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21" [[package]] name = "sized-chunks" @@ -5590,15 +5480,15 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.13.2" +version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" +checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" [[package]] name = "socket2" -version = "0.4.10" +version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d" +checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662" dependencies = [ "libc", "winapi", @@ -5606,12 +5496,12 @@ dependencies = [ [[package]] name = "socket2" -version = "0.5.6" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871" +checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.48.0", ] [[package]] @@ -5632,12 +5522,12 @@ dependencies = [ [[package]] name = "solana-account-decoder" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d145d4e1e33bfecd209059a0c4c75d623dbcaeb565b4c197f1815257be45726a" +checksum = "8d76c43ef61f527d719b5c6bfa5a62ebba60839739125da9e8a00fb82349afd2" dependencies = [ "Inflector", - "base64 0.21.7", + "base64 0.21.4", "bincode", "bs58 0.4.0", "bv", @@ -5657,9 +5547,9 @@ dependencies = [ [[package]] name = "solana-clap-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1deaf83f98be3ba9ecee057efa5cdfa6112267e5b1ff53c4ef4b727f66090b9a" +checksum = "eb19b9bbd92eee2d8f637026559a9fb48bd98aba534caedf070498a50c91fce8" dependencies = [ "chrono", "clap 2.34.0", @@ -5674,16 +5564,16 @@ dependencies = [ [[package]] name = "solana-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a8912026a203ff0d90973e7363f141c6ce569484e06ee0a6f72992144263136" +checksum = "9538e3db584a8b1e70060f1f24222b8e0429f18b607f531fb45eb826f4917265" dependencies = [ "async-trait", "bincode", "dashmap 4.0.2", "futures", "futures-util", - "indexmap 2.2.6", + "indexmap 2.0.2", "indicatif", "log", "quinn", @@ -5707,9 +5597,9 @@ dependencies = [ [[package]] name = "solana-config-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4000f4717f86c5f9e1105378e3a6521db770d0ad68417f59960ca4b51103fcd0" +checksum = "e3afd4e309d304e296765cab716fb1fd66c66ec300465c8b26f8cce763275132" dependencies = [ "bincode", "chrono", @@ -5721,15 +5611,15 @@ dependencies = [ [[package]] name = "solana-connection-cache" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8b1a4d67c01e5c4464ed9bffb656dec2c88e9bfd7d45bf754f650150e5d81db" +checksum = "92716758e8c0e1c0bc2a5ac2eb3df443a0337fd3991cd38a3b02b12c3fbd18ce" dependencies = [ "async-trait", "bincode", "crossbeam-channel", "futures-util", - "indexmap 2.2.6", + "indexmap 2.0.2", "log", "rand 0.8.5", "rayon", @@ -5743,9 +5633,9 @@ dependencies = [ [[package]] name = "solana-frozen-abi" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1790013c7969353000c22907fc21610adb3389a7c9a27a386ebe7fb32b2ad307" +checksum = "fb1b8230474ae9f7c841060c299999124582e8d2a0448d7847720792e98cc64e" dependencies = [ "ahash 0.8.5", "blake3", @@ -5773,21 +5663,21 @@ dependencies = [ [[package]] name = "solana-frozen-abi-macro" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3ed2b49a3dd03ddd5107d6e629e8e5895724227a057b3511bf0c107c6d48308" +checksum = "793910ab733b113b80c357f8f492dda2fabd5671c4ea03db3aa4e46b938fdbe3" dependencies = [ "proc-macro2", "quote", "rustc_version", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "solana-logger" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfc0d5b4f046d07e845b69178989a6b3bf168a82eeee006adb77391b339bce64" +checksum = "6d3f819af39632dc538a566c937253bf46256e4c0e60f621c6db448bc7c76294" dependencies = [ "env_logger 0.9.3", "lazy_static", @@ -5796,9 +5686,9 @@ dependencies = [ [[package]] name = "solana-measure" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "857178177c6b378bcfc35df6867a6eef211059f5e4ab01ee87355d6b7493b556" +checksum = "cb045f0235b16f7d926f6e0338db822747d61559a1368c3cb017ba6e02c516d0" dependencies = [ "log", "solana-sdk", @@ -5806,9 +5696,9 @@ dependencies = [ [[package]] name = "solana-metrics" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c68f5cbfbafd002b4d94728748f632a3bd27772ca5c7139710d65940c95477c" +checksum = "1af84362ad5804dc64ca88b1ca5c35bd41321e12d42c798ac06a6fbb60dd0e70" dependencies = [ "crossbeam-channel", "gethostname", @@ -5821,9 +5711,9 @@ dependencies = [ [[package]] name = "solana-net-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce93c50199f077df9d8fd4a82bbdfe654422e1d21e5eecb7f878c4e0078f92f" +checksum = "f8e640a95d317cad1322015c5a2b6a71697fd8dabebcb8dd33ed7f5a22869d12" dependencies = [ "bincode", "clap 3.2.25", @@ -5833,7 +5723,7 @@ dependencies = [ "rand 0.8.5", "serde", "serde_derive", - "socket2 0.5.6", + "socket2 0.5.4", "solana-logger", "solana-sdk", "solana-version", @@ -5843,9 +5733,9 @@ dependencies = [ [[package]] name = "solana-perf" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a233bc2032f4b3f462fe13325cd1a336f355e1d9e793faada488db409cec0d6" +checksum = "4266c4bd46620a925b8d508c26578d5559e97fcff6735fd22e39f369c3996ee1" dependencies = [ "ahash 0.8.5", "bincode", @@ -5872,17 +5762,17 @@ dependencies = [ [[package]] name = "solana-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b2ae4ec9dd6fc76202c94d23942da3cf624325a178e1b0125e70db90b8d7f15" +checksum = "581f38a870bffbe623d900c68579984671f8dfa35bbfb3309d7134de22ce8652" dependencies = [ "ark-bn254", "ark-ec", "ark-ff", "ark-serialize", - "base64 0.21.7", + "base64 0.21.4", "bincode", - "bitflags 2.5.0", + "bitflags 2.4.0", "blake3", "borsh 0.10.3", "borsh 0.9.3", @@ -5893,7 +5783,7 @@ dependencies = [ "console_error_panic_hook", "console_log", "curve25519-dalek", - "getrandom 0.2.14", + "getrandom 0.2.10", "itertools 0.10.5", "js-sys", "lazy_static", @@ -5901,7 +5791,7 @@ dependencies = [ "libsecp256k1", "light-poseidon", "log", - "memoffset 0.9.1", + "memoffset 0.9.0", "num-bigint 0.4.4", "num-derive 0.3.3", "num-traits", @@ -5926,11 +5816,11 @@ dependencies = [ [[package]] name = "solana-program-runtime" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b50a6da7b501117f68ef51fc113d771b52af646dc42c43af23a85e32461d59c9" +checksum = "490b6f65aced077e0c5e57c20f151a134458fc350905c20d7dcf3f2162eaa6f6" dependencies = [ - "base64 0.21.7", + "base64 0.21.4", "bincode", "eager", "enum-iterator", @@ -5954,9 +5844,9 @@ dependencies = [ [[package]] name = "solana-pubsub-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf920143eb7d5bd5f2ea8fc6ab8a1f521512dfe50af7833af40d7cbae83d955d" +checksum = "c0dc2b26a7a9860f180ce11f69b0ff2a8bea0d4b9e97daee741b1e76565b3c82" dependencies = [ "crossbeam-channel", "futures-util", @@ -5979,9 +5869,9 @@ dependencies = [ [[package]] name = "solana-quic-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "627491c0afd615efb2538c8a49948663ac01aadf99a3cfebb0a63e2b9431ed79" +checksum = "727474945d51be37ffe03e7b1d6c9630da41228c7b298a8f45098c203a78ac89" dependencies = [ "async-mutex", "async-trait", @@ -5992,7 +5882,7 @@ dependencies = [ "quinn", "quinn-proto", "rcgen", - "rustls 0.21.10", + "rustls 0.21.7", "solana-connection-cache", "solana-measure", "solana-metrics", @@ -6006,9 +5896,9 @@ dependencies = [ [[package]] name = "solana-rayon-threadlimit" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d5c306f32e26031c043c218a0ba3cde08cbb0e08511ab8a4128445d92a535e0" +checksum = "853794cccf3bd1984419a594040dfed19666e5a9ad33b0906d4174bc394b22af" dependencies = [ "lazy_static", "num_cpus", @@ -6016,9 +5906,9 @@ dependencies = [ [[package]] name = "solana-remote-wallet" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1c9dbb8cca1b917a01979a1ca98b682f6123df56f11a5227a37c36494ad7740" +checksum = "b368f270526a5f92ec47c45a6b74ac304b62b08c169b45cf91e0d2f1703889bd" dependencies = [ "console", "dialoguer", @@ -6035,12 +5925,12 @@ dependencies = [ [[package]] name = "solana-rpc-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2edc8c0f26561e770f28edb9d456221a5554ee90eeb9052ed38942dbb31c035b" +checksum = "71b766876b0c56950ab530d8495ef7eeaeb79e162f03dadaffc0d6852de9e844" dependencies = [ "async-trait", - "base64 0.21.7", + "base64 0.21.4", "bincode", "bs58 0.4.0", "indicatif", @@ -6061,11 +5951,11 @@ dependencies = [ [[package]] name = "solana-rpc-client-api" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ff63ab63805a6302ec21284a1138daf5478020f79641d77e53bb84f16c1f5a6" +checksum = "876b2e410cc2403ea3216893f05034b02a180431100eb831d0b67b14fca4d29f" dependencies = [ - "base64 0.21.7", + "base64 0.21.4", "bs58 0.4.0", "jsonrpc-core", "reqwest", @@ -6083,9 +5973,9 @@ dependencies = [ [[package]] name = "solana-rpc-client-nonce-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "897db0c1085b8a99ca35871132b6dc6dca3eff68d9210fcd168ccc2e3843dc26" +checksum = "ebdb3f02fb3cce3c967f718bc77b79433c24aa801b63dc70f374e8759b2424e4" dependencies = [ "clap 2.34.0", "solana-clap-utils", @@ -6096,14 +5986,14 @@ dependencies = [ [[package]] name = "solana-sdk" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "368430d6c9f033e86f8f590d19232d10986d1188c3ad3a6836628d2acc09c21a" +checksum = "0d70ab837cc79ed67df6fdb145f1ffd544f1eaa60b0757b750f4864b90498bad" dependencies = [ "assert_matches", - "base64 0.21.7", + "base64 0.21.4", "bincode", - "bitflags 2.5.0", + "bitflags 2.4.0", "borsh 0.10.3", "bs58 0.4.0", "bytemuck", @@ -6150,15 +6040,15 @@ dependencies = [ [[package]] name = "solana-sdk-macro" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f554d2a144bb0138cfdeced9961cc8a09aaa09f0c3c9a63bd10da41c4a06d420" +checksum = "5f9d0433c4084a3260a32ec67f6b4272c4232d15e732be542cd5dfdf0ae1e784" dependencies = [ "bs58 0.4.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -6169,16 +6059,16 @@ checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183" [[package]] name = "solana-streamer" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e28e8941bc0b137f851626ff4d4ce9ebcf9be10619b48d2ed83cd1953af21821" +checksum = "d70eda40efb5bc57ad50b1ac8452485065c1adae0e701a0348b397db054e2ab5" dependencies = [ "async-channel 1.9.0", "bytes", "crossbeam-channel", "futures-util", "histogram", - "indexmap 2.2.6", + "indexmap 2.0.2", "itertools 0.10.5", "libc", "log", @@ -6190,7 +6080,7 @@ dependencies = [ "quinn-proto", "rand 0.8.5", "rcgen", - "rustls 0.21.10", + "rustls 0.21.7", "solana-metrics", "solana-perf", "solana-sdk", @@ -6201,9 +6091,9 @@ dependencies = [ [[package]] name = "solana-thin-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "760b94e2875b54350f786c85faf50fa1a9a37ae46e9897215d19b373fc2f58cd" +checksum = "ca3c510144695c3d1ee1f84dd9975af7f7d35c168447c484bbd35c21e903c515" dependencies = [ "bincode", "log", @@ -6216,14 +6106,14 @@ dependencies = [ [[package]] name = "solana-tpu-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cfdc7ff6cdc1512661de1f9f40723f88dc1e94c8b8938bd537f3713239173e2" +checksum = "44f27c8fec609179a7dfc287060df2a926c8cd89329235c4b8d78bd019a72462" dependencies = [ "async-trait", "bincode", "futures-util", - "indexmap 2.2.6", + "indexmap 2.0.2", "indicatif", "log", "rayon", @@ -6240,12 +6130,12 @@ dependencies = [ [[package]] name = "solana-transaction-status" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba7131d11c8d5a068bfc26a9dc8c9ee0d77eaf60856dd0c8be880542fc5fbbd6" +checksum = "29f58f2f864d900eddf2e21a99ebe445b6be525d597e44952f075d8237035b8e" dependencies = [ "Inflector", - "base64 0.21.7", + "base64 0.21.4", "bincode", "borsh 0.10.3", "bs58 0.4.0", @@ -6265,9 +6155,9 @@ dependencies = [ [[package]] name = "solana-udp-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54647340d7fa1708c217cbc2411259c5b3784c2df55c1eb4353aca296635ed87" +checksum = "27ead118c5d549e4345dc59cbc5d9b282164f3e5334707f186e3aa10d40e3b30" dependencies = [ "async-trait", "solana-connection-cache", @@ -6280,9 +6170,9 @@ dependencies = [ [[package]] name = "solana-version" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1de7a6bad7dff1c595be2eec0c3800a482c6068f3c87c6df87ed091b4e6e642e" +checksum = "532f5d631562587facc5fe88abd2e31c0d1f29012b6766c664db9f05a39fb05b" dependencies = [ "log", "rustc_version", @@ -6296,9 +6186,9 @@ dependencies = [ [[package]] name = "solana-vote-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c828d118d1f135baacfbf51412c4f1ac18af19fdbee43b002d2908e69cdf50b" +checksum = "c684430058b0a2e733936a8851c8843a3a6316ccd5c969d39411a479d6489642" dependencies = [ "bincode", "log", @@ -6318,12 +6208,12 @@ dependencies = [ [[package]] name = "solana-zk-token-sdk" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "112944743b08f7e1101368ff6d84745e7b4abb075fabaccc02e01bd3ce4b6d6c" +checksum = "5aef1b48d9fdb2619349d2d15942d83c99aabe995ff945d9b418176373aa823c" dependencies = [ "aes-gcm-siv", - "base64 0.21.7", + "base64 0.21.4", "bincode", "bytemuck", "byteorder", @@ -6406,7 +6296,7 @@ checksum = "992d9c64c2564cc8f63a4b508bf3ebcdf2254b0429b13cd1d31adb6162432a5f" dependencies = [ "assert_matches", "borsh 0.10.3", - "num-derive 0.4.2", + "num-derive 0.4.1", "num-traits", "solana-program", "spl-token", @@ -6427,9 +6317,9 @@ dependencies = [ [[package]] name = "spl-discriminator" -version = "0.1.1" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "daa600f2fe56f32e923261719bae640d873edadbc5237681a39b8e37bfd4d263" +checksum = "cce5d563b58ef1bb2cdbbfe0dfb9ffdc24903b10ae6a4df2d8f425ece375033f" dependencies = [ "bytemuck", "solana-program", @@ -6438,25 +6328,25 @@ dependencies = [ [[package]] name = "spl-discriminator-derive" -version = "0.1.2" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07fd7858fc4ff8fb0e34090e41d7eb06a823e1057945c26d480bfc21d2338a93" +checksum = "fadbefec4f3c678215ca72bd71862697bb06b41fd77c0088902dd3203354387b" dependencies = [ "quote", "spl-discriminator-syn", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "spl-discriminator-syn" -version = "0.1.2" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18fea7be851bd98d10721782ea958097c03a0c2a07d8d4997041d0ece6319a63" +checksum = "0e5f2044ca42c8938d54d1255ce599c79a1ffd86b677dfab695caa20f9ffc3f2" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.58", + "syn 2.0.38", "thiserror", ] @@ -6480,11 +6370,11 @@ dependencies = [ [[package]] name = "spl-pod" -version = "0.1.1" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85a5db7e4efb1107b0b8e52a13f035437cdcb36ef99c58f6d467f089d9b2915a" +checksum = "2881dddfca792737c0706fa0175345ab282b1b0879c7d877bad129645737c079" dependencies = [ - "base64 0.21.7", + "base64 0.21.4", "borsh 0.10.3", "bytemuck", "serde", @@ -6495,11 +6385,11 @@ dependencies = [ [[package]] name = "spl-program-error" -version = "0.3.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e0657b6490196971d9e729520ba934911ff41fbb2cb9004463dbe23cf8b4b4f" +checksum = "249e0318493b6bcf27ae9902600566c689b7dfba9f1bdff5893e92253374e78c" dependencies = [ - "num-derive 0.4.2", + "num-derive 0.4.1", "num-traits", "solana-program", "spl-program-error-derive", @@ -6508,14 +6398,14 @@ dependencies = [ [[package]] name = "spl-program-error-derive" -version = "0.3.2" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1845dfe71fd68f70382232742e758557afe973ae19e6c06807b2c30f5d5cb474" +checksum = "ab5269c8e868da17b6552ef35a51355a017bd8e0eae269c201fef830d35fa52c" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -6555,7 +6445,7 @@ checksum = "d697fac19fd74ff472dfcc13f0b442dd71403178ce1de7b5d16f83a33561c059" dependencies = [ "arrayref", "bytemuck", - "num-derive 0.4.2", + "num-derive 0.4.1", "num-traits", "num_enum 0.7.2", "solana-program", @@ -6616,9 +6506,9 @@ dependencies = [ [[package]] name = "spl-type-length-value" -version = "0.3.1" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f9ebd75d29c5f48de5f6a9c114e08531030b75b8ac2c557600ac7da0b73b1e8" +checksum = "a468e6f6371f9c69aae760186ea9f1a01c2908351b06a5e0026d21cfc4d7ecac" dependencies = [ "bytemuck", "solana-program", @@ -6629,11 +6519,11 @@ dependencies = [ [[package]] name = "sqlformat" -version = "0.2.3" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce81b7bd7c4493975347ef60d8c7e8b742d4694f4c49f93e0a12ea263938176c" +checksum = "6b7b278788e7be4d0d29c0f39497a0eef3fba6bbc8e70d8bf7fde46edeaa9e85" dependencies = [ - "itertools 0.12.1", + "itertools 0.11.0", "nom", "unicode_categories", ] @@ -6654,7 +6544,7 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fa8241483a83a3f33aa5fff7e7d9def398ff9990b2752b6c6112b83c6d246029" dependencies = [ - "ahash 0.7.8", + "ahash 0.7.6", "atoi", "base64 0.13.1", "bitflags 1.3.2", @@ -6698,7 +6588,7 @@ dependencies = [ "sqlx-rt", "stringprep", "thiserror", - "time 0.3.35", + "time 0.3.29", "tokio-stream", "url", "uuid", @@ -6752,7 +6642,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6bcb902b974bc20b50c3ad3148022a366a46c9a676b587684ff46c237a3329e" dependencies = [ "async-channel 1.9.0", - "async-io 1.13.0", + "async-io", "atomic 0.5.3", "crossbeam-channel", "futures", @@ -6787,12 +6677,6 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" -[[package]] -name = "strsim" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" - [[package]] name = "subtle" version = "2.4.1" @@ -6812,33 +6696,15 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.58" +version = "2.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687" +checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] -[[package]] -name = "syn_derive" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b" -dependencies = [ - "proc-macro-error", - "proc-macro2", - "quote", - "syn 2.0.58", -] - -[[package]] -name = "sync_wrapper" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" - [[package]] name = "synstructure" version = "0.12.6" @@ -6880,21 +6746,22 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "tempfile" -version = "3.10.1" +version = "3.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" +checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef" dependencies = [ "cfg-if", - "fastrand 2.0.2", - "rustix 0.38.32", - "windows-sys 0.52.0", + "fastrand 2.0.1", + "redox_syscall 0.3.5", + "rustix 0.38.18", + "windows-sys 0.48.0", ] [[package]] name = "termcolor" -version = "1.4.1" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64" dependencies = [ "winapi-util", ] @@ -6910,35 +6777,35 @@ dependencies = [ [[package]] name = "textwrap" -version = "0.16.1" +version = "0.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9" +checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d" [[package]] name = "thiserror" -version = "1.0.58" +version = "1.0.49" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297" +checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.58" +version = "1.0.49" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7" +checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "thread_local" -version = "1.1.8" +version = "1.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" +checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152" dependencies = [ "cfg-if", "once_cell", @@ -6957,14 +6824,12 @@ dependencies = [ [[package]] name = "time" -version = "0.3.35" +version = "0.3.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef89ece63debf11bc32d1ed8d078ac870cbeb44da02afb02a9ff135ae7ca0582" +checksum = "426f806f4089c493dcac0d24c29c01e2c38baf8e30f1b716ee37e83d200b18fe" dependencies = [ "deranged", "itoa", - "num-conv", - "powerfmt", "serde", "time-core", "time-macros", @@ -6978,11 +6843,10 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" [[package]] name = "time-macros" -version = "0.2.18" +version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" +checksum = "4ad70d68dba9e1f8aceda7aa6711965dfec1cac869f311a51bd08b3a2ccbce20" dependencies = [ - "num-conv", "time-core", ] @@ -7022,9 +6886,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.37.0" +version = "1.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" +checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653" dependencies = [ "backtrace", "bytes", @@ -7034,7 +6898,7 @@ dependencies = [ "parking_lot 0.12.1", "pin-project-lite", "signal-hook-registry", - "socket2 0.5.6", + "socket2 0.5.4", "tokio-macros", "tracing", "windows-sys 0.48.0", @@ -7042,13 +6906,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.2.0" +version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" +checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -7078,15 +6942,15 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ - "rustls 0.21.10", + "rustls 0.21.7", "tokio", ] [[package]] name = "tokio-stream" -version = "0.1.15" +version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af" +checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842" dependencies = [ "futures-core", "pin-project-lite", @@ -7101,18 +6965,18 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" dependencies = [ "futures-util", "log", - "rustls 0.21.10", + "rustls 0.21.7", "tokio", "tokio-rustls 0.24.1", "tungstenite", - "webpki-roots 0.25.4", + "webpki-roots 0.25.2", ] [[package]] name = "tokio-util" -version = "0.7.10" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" +checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d" dependencies = [ "bytes", "futures-core", @@ -7134,14 +6998,14 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.12" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3" +checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35" dependencies = [ "serde", "serde_spanned", "toml_datetime", - "toml_edit 0.22.9", + "toml_edit 0.21.0", ] [[package]] @@ -7159,33 +7023,22 @@ version = "0.19.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" dependencies = [ - "indexmap 2.2.6", - "toml_datetime", - "winnow 0.5.40", -] - -[[package]] -name = "toml_edit" -version = "0.21.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" -dependencies = [ - "indexmap 2.2.6", + "indexmap 2.0.2", "toml_datetime", - "winnow 0.5.40", + "winnow", ] [[package]] name = "toml_edit" -version = "0.22.9" +version = "0.21.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e40bb779c5187258fd7aad0eb68cb8706a0a81fa712fbea808ab43c4b8374c4" +checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03" dependencies = [ - "indexmap 2.2.6", + "indexmap 2.0.2", "serde", "serde_spanned", "toml_datetime", - "winnow 0.6.5", + "winnow", ] [[package]] @@ -7231,10 +7084,11 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" [[package]] name = "tracing" -version = "0.1.40" +version = "0.1.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" dependencies = [ + "cfg-if", "log", "pin-project-lite", "tracing-attributes", @@ -7243,20 +7097,20 @@ dependencies = [ [[package]] name = "tracing-attributes" -version = "0.1.27" +version = "0.1.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" +checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] name = "tracing-core" -version = "0.1.32" +version = "0.1.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" +checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a" dependencies = [ "once_cell", "valuable", @@ -7311,9 +7165,9 @@ dependencies = [ "anchor-client", "anyhow", "bs58 0.4.0", - "clap 4.5.4", + "clap 4.4.8", "digital_asset_types", - "env_logger 0.10.2", + "env_logger 0.10.0", "flatbuffers", "futures", "hex", @@ -7335,9 +7189,9 @@ dependencies = [ [[package]] name = "triomphe" -version = "0.1.11" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3" +checksum = "0eee8098afad3fb0c54a9007aab6804558410503ad676d4633f9c2559a00ac0f" dependencies = [ "serde", "stable_deref_trait", @@ -7345,9 +7199,9 @@ dependencies = [ [[package]] name = "try-lock" -version = "0.2.5" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" [[package]] name = "tungstenite" @@ -7362,7 +7216,7 @@ dependencies = [ "httparse", "log", "rand 0.8.5", - "rustls 0.21.10", + "rustls 0.21.7", "sha1", "thiserror", "url", @@ -7375,8 +7229,8 @@ name = "txn_forwarder" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.5.4", - "env_logger 0.10.2", + "clap 4.4.8", + "env_logger 0.10.0", "figment", "flatbuffers", "futures", @@ -7403,9 +7257,9 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" [[package]] name = "uncased" -version = "0.9.10" +version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697" +checksum = "9b9bc53168a4be7402ab86c3aad243a84dd7381d09be0eddc81280c1da95ca68" dependencies = [ "version_check", ] @@ -7421,9 +7275,9 @@ dependencies = [ [[package]] name = "unicode-bidi" -version = "0.3.15" +version = "0.3.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" +checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" [[package]] name = "unicode-ident" @@ -7433,18 +7287,18 @@ checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" [[package]] name = "unicode-normalization" -version = "0.1.23" +version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" +checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.11.0" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202" +checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36" [[package]] name = "unicode-width" @@ -7485,9 +7339,9 @@ dependencies = [ [[package]] name = "unsafe-libyaml" -version = "0.2.11" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" +checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa" [[package]] name = "untrusted" @@ -7513,9 +7367,9 @@ dependencies = [ [[package]] name = "url" -version = "2.5.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" +checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" dependencies = [ "form_urlencoded", "idna", @@ -7536,11 +7390,11 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" [[package]] name = "uuid" -version = "1.8.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" +checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d" dependencies = [ - "getrandom 0.2.14", + "getrandom 0.2.10", "serde", ] @@ -7552,9 +7406,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" [[package]] name = "value-bag" -version = "1.8.1" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74797339c3b98616c009c7c3eb53a0ce41e85c8ec66bd3db96ed132d20cfdee8" +checksum = "4a72e1902dde2bd6441347de2b70b7f5d59bf157c6c62f0c44572607a1d55bbe" [[package]] name = "vcpkg" @@ -7595,12 +7449,6 @@ dependencies = [ "try-lock", ] -[[package]] -name = "wasi" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b89c3ce4ce14bdc6fb6beaf9ec7928ca331de5df7e5ea278375642a2f478570d" - [[package]] name = "wasi" version = "0.9.0+wasi-snapshot-preview1" @@ -7619,17 +7467,11 @@ version = "0.11.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" -[[package]] -name = "wasite" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" - [[package]] name = "wasm-bindgen" -version = "0.2.92" +version = "0.2.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" +checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -7637,24 +7479,24 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.92" +version = "0.2.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" +checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd" dependencies = [ "bumpalo", "log", "once_cell", "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.42" +version = "0.4.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" +checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03" dependencies = [ "cfg-if", "js-sys", @@ -7664,9 +7506,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.92" +version = "0.2.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" +checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -7674,28 +7516,28 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.92" +version = "0.2.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" +checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.92" +version = "0.2.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" +checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1" [[package]] name = "web-sys" -version = "0.3.69" +version = "0.3.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" +checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b" dependencies = [ "js-sys", "wasm-bindgen", @@ -7707,7 +7549,7 @@ version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53" dependencies = [ - "ring 0.17.8", + "ring 0.17.2", "untrusted 0.9.0", ] @@ -7731,9 +7573,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.25.4" +version = "0.25.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" +checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" [[package]] name = "wg" @@ -7748,12 +7590,11 @@ dependencies = [ [[package]] name = "whoami" -version = "1.5.1" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9" +checksum = "22fc3756b8a9133049b26c7f61ab35416c130e8c09b660f5b3958b446f52cc50" dependencies = [ - "redox_syscall 0.4.1", - "wasite", + "wasm-bindgen", "web-sys", ] @@ -7789,12 +7630,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] -name = "windows-core" -version = "0.52.0" +name = "windows" +version = "0.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" +checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" dependencies = [ - "windows-targets 0.52.4", + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets 0.42.2", ] [[package]] @@ -7807,12 +7657,18 @@ dependencies = [ ] [[package]] -name = "windows-sys" -version = "0.52.0" +name = "windows-targets" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" dependencies = [ - "windows-targets 0.52.4", + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", ] [[package]] @@ -7831,19 +7687,10 @@ dependencies = [ ] [[package]] -name = "windows-targets" -version = "0.52.4" +name = "windows_aarch64_gnullvm" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b" -dependencies = [ - "windows_aarch64_gnullvm 0.52.4", - "windows_aarch64_msvc 0.52.4", - "windows_i686_gnu 0.52.4", - "windows_i686_msvc 0.52.4", - "windows_x86_64_gnu 0.52.4", - "windows_x86_64_gnullvm 0.52.4", - "windows_x86_64_msvc 0.52.4", -] +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" [[package]] name = "windows_aarch64_gnullvm" @@ -7852,10 +7699,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.4" +name = "windows_aarch64_msvc" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" [[package]] name = "windows_aarch64_msvc" @@ -7864,10 +7711,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] -name = "windows_aarch64_msvc" -version = "0.52.4" +name = "windows_i686_gnu" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" [[package]] name = "windows_i686_gnu" @@ -7876,10 +7723,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] -name = "windows_i686_gnu" -version = "0.52.4" +name = "windows_i686_msvc" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" [[package]] name = "windows_i686_msvc" @@ -7888,10 +7735,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] -name = "windows_i686_msvc" -version = "0.52.4" +name = "windows_x86_64_gnu" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" [[package]] name = "windows_x86_64_gnu" @@ -7900,10 +7747,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] -name = "windows_x86_64_gnu" -version = "0.52.4" +name = "windows_x86_64_gnullvm" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" [[package]] name = "windows_x86_64_gnullvm" @@ -7912,10 +7759,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.4" +name = "windows_x86_64_msvc" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" [[package]] name = "windows_x86_64_msvc" @@ -7923,26 +7770,11 @@ version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8" - [[package]] name = "winnow" -version = "0.5.40" +version = "0.5.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" -dependencies = [ - "memchr", -] - -[[package]] -name = "winnow" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dffa400e67ed5a4dd237983829e66475f0a4a26938c4b04c21baede6262215b8" +checksum = "037711d82167854aff2018dfd193aa0fef5370f456732f0d5a0c59b0f1b4b907" dependencies = [ "memchr", ] @@ -7981,20 +7813,29 @@ dependencies = [ "oid-registry", "rusticata-macros", "thiserror", - "time 0.3.35", + "time 0.3.29", ] [[package]] name = "xxhash-rust" -version = "0.8.10" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9828b178da53440fa9c766a3d2f73f7cf5d0ac1fe3980c1e5018d899fd19e07b" + +[[package]] +name = "yaml-rust" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03" +checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85" +dependencies = [ + "linked-hash-map", +] [[package]] name = "yansi" -version = "1.0.1" +version = "1.0.0-rc.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" +checksum = "1367295b8f788d371ce2dbc842c7b709c73ee1364d30351dd300ec2203b12377" [[package]] name = "yasna" @@ -8002,7 +7843,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd" dependencies = [ - "time 0.3.35", + "time 0.3.29", ] [[package]] @@ -8022,7 +7863,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -8042,7 +7883,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.58", + "syn 2.0.38", ] [[package]] @@ -8066,10 +7907,11 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.10+zstd.1.5.6" +version = "2.0.8+zstd.1.5.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa" +checksum = "5556e6ee25d32df2586c098bbfa278803692a20d0ab9565e049480d52707ec8c" dependencies = [ "cc", + "libc", "pkg-config", ] diff --git a/das_api/Cargo.toml b/das_api/Cargo.toml index d41028193..566ac1cd8 100644 --- a/das_api/Cargo.toml +++ b/das_api/Cargo.toml @@ -12,39 +12,25 @@ blockbuster = { workspace = true } bs58 = { workspace = true } cadence = { workspace = true } cadence-macros = { workspace = true } -digital_asset_types = { workspace = true, features = [ - "json_types", - "sql_types", -] } -env_logger = { workspace = true } +digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } +env_logger = { workspace = true } figment = { workspace = true, features = ["env"] } hyper = { workspace = true } -jsonrpsee = { workspace = true, features = ["server", "macros"] } -jsonrpsee-core = { workspace = true, features = ["server"] } +jsonrpsee = { workspace = true, features = ["server", "macros"]} +jsonrpsee-core = { workspace = true, features =["server"]} log = { workspace = true } metrics = { workspace = true } mpl-bubblegum = { workspace = true } -mpl-token-metadata = { workspace = true, features = ["serde"] } +mpl-token-metadata = { workspace = true, features = ["serde"] } open-rpc-derive = { workspace = true } open-rpc-schema = { workspace = true } schemars = { workspace = true } schemars_derive = { workspace = true } -sea-orm = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "sqlx-postgres", -] } +sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres"] } serde = { workspace = true } serde_json = { workspace = true } solana-sdk = { workspace = true } -sqlx = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "postgres", - "uuid", - "offline", - "json", -] } +sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } thiserror = { workspace = true } tokio = { workspace = true, features = ["signal"] } tower = { workspace = true } diff --git a/digital_asset_types/Cargo.toml b/digital_asset_types/Cargo.toml index 74fb32353..449f6e78d 100644 --- a/digital_asset_types/Cargo.toml +++ b/digital_asset_types/Cargo.toml @@ -8,7 +8,7 @@ publish = { workspace = true } [dependencies] async-trait = { workspace = true } blockbuster = { workspace = true } -borsh = { workspace = true, optional = true } +borsh = { workspace = true, optional = true } borsh-derive = { workspace = true, optional = true } bs58 = { workspace = true } futures = { workspace = true } @@ -20,18 +20,10 @@ num-derive = { workspace = true } num-traits = { workspace = true } schemars = { workspace = true } schemars_derive = { workspace = true } -sea-orm = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "sqlx-postgres", - "with-chrono", - "mock", -], optional = true } +sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"], optional = true } sea-query = { workspace = true, features = ["postgres-array"] } serde = { workspace = true, optional = true } -serde_json = { workspace = true, features = [ - "preserve_order", -], optional = true } +serde_json = { workspace = true, features = ["preserve_order"], optional = true } solana-sdk = { workspace = true } spl-concurrent-merkle-tree = { workspace = true } thiserror = { workspace = true } diff --git a/digital_asset_types/src/dao/scopes/asset.rs b/digital_asset_types/src/dao/scopes/asset.rs index 2df576591..58e4cbbaf 100644 --- a/digital_asset_types/src/dao/scopes/asset.rs +++ b/digital_asset_types/src/dao/scopes/asset.rs @@ -1,7 +1,10 @@ use crate::{ dao::{ - asset, asset_authority, asset_creators, asset_data, asset_grouping, cl_audits_v2, - extensions, Cursor, FullAsset, GroupingSize, Pagination, + asset::{self}, + asset_authority, asset_creators, asset_data, asset_grouping, cl_audits_v2, + extensions::{self, instruction::PascalCase}, + sea_orm_active_enums::Instruction, + Cursor, FullAsset, GroupingSize, Pagination, }, rpc::filter::AssetSortDirection, }; @@ -462,8 +465,7 @@ pub async fn fetch_transactions( .into_iter() .map(|transaction| { let tx = bs58::encode(transaction.tx).into_string(); - let ix = extensions::instruction::PascalCase::to_pascal_case(&transaction.instruction) - .to_string(); + let ix = Instruction::to_pascal_case(&transaction.instruction).to_string(); (tx, ix) }) .collect(); diff --git a/metaplex-rpc-proxy/Cargo.toml b/metaplex-rpc-proxy/Cargo.toml index 2e69785dd..06b801543 100644 --- a/metaplex-rpc-proxy/Cargo.toml +++ b/metaplex-rpc-proxy/Cargo.toml @@ -13,8 +13,6 @@ lazy_static = { workspace = true } log = { workspace = true } proxy-wasm = { workspace = true } regex = { workspace = true } -wasi = { workspace = true } -wasm-bindgen = { workspace = true } [lints] workspace = true diff --git a/nft_ingester/Cargo.toml b/nft_ingester/Cargo.toml index db41c0a1f..1eb403ca0 100644 --- a/nft_ingester/Cargo.toml +++ b/nft_ingester/Cargo.toml @@ -8,7 +8,6 @@ publish = { workspace = true } [dependencies] async-trait = { workspace = true } -blockbuster = { workspace = true } borsh = { workspace = true } bs58 = { workspace = true } cadence = { workspace = true } diff --git a/nft_ingester/src/backfiller.rs b/nft_ingester/src/backfiller.rs index fcf27fad3..7d7b32060 100644 --- a/nft_ingester/src/backfiller.rs +++ b/nft_ingester/src/backfiller.rs @@ -961,7 +961,7 @@ impl<'a, T: Messenger> Backfiller<'a, T> { // Filter out transactions that don't have to do with the tree we are interested in or // the Bubblegum program. let tb = tree.to_bytes(); - let bubblegum = blockbuster::programs::bubblegum::ID.to_bytes(); + let bubblegum = mpl_bubblegum::ID.to_bytes(); if account_keys.iter().all(|pk| *pk != tb && *pk != bubblegum) { continue; } diff --git a/tools/bgtask_creator/Cargo.toml b/tools/bgtask_creator/Cargo.toml index be662e34e..7011185e5 100644 --- a/tools/bgtask_creator/Cargo.toml +++ b/tools/bgtask_creator/Cargo.toml @@ -8,32 +8,16 @@ publish = { workspace = true } [dependencies] anyhow = { workspace = true } clap = { workspace = true, features = ["derive", "cargo"] } -digital_asset_types = { workspace = true, features = [ - "json_types", - "sql_types", -] } +digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } futures = { workspace = true } lazy_static = { workspace = true } log = { workspace = true } nft_ingester = { workspace = true } prometheus = { workspace = true } -sea-orm = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "sqlx-postgres", - "with-chrono", - "mock", -] } +sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"] } sea-query = { workspace = true, features = ["postgres-array"] } solana-sdk = { workspace = true } -sqlx = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "postgres", - "uuid", - "offline", - "json", -] } +sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } txn_forwarder = { workspace = true } diff --git a/tools/load_generation/Cargo.toml b/tools/load_generation/Cargo.toml index 0c7a97d19..bd7b0de3b 100644 --- a/tools/load_generation/Cargo.toml +++ b/tools/load_generation/Cargo.toml @@ -12,9 +12,7 @@ rand = { workspace = true } solana-client = { workspace = true } solana-program = { workspace = true } solana-sdk = { workspace = true } -spl-associated-token-account = { workspace = true, features = [ - "no-entrypoint", -] } +spl-associated-token-account = { workspace = true, features = ["no-entrypoint"] } spl-token = { workspace = true, features = ["no-entrypoint"] } tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } diff --git a/tools/tree-status/Cargo.toml b/tools/tree-status/Cargo.toml index 3ff2e0c37..da8ccc058 100644 --- a/tools/tree-status/Cargo.toml +++ b/tools/tree-status/Cargo.toml @@ -8,15 +8,11 @@ repository = { workspace = true } publish = { workspace = true } [dependencies] - anchor-client = { workspace = true } anyhow = { workspace = true } bs58 = { workspace = true } clap = { workspace = true, features = ["derive"] } -digital_asset_types = { workspace = true, features = [ - "json_types", - "sql_types", -] } +digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } env_logger = { workspace = true } flatbuffers = { workspace = true } futures = { workspace = true } @@ -24,35 +20,16 @@ hex = { workspace = true } lazy_static = { workspace = true } log = { workspace = true } prometheus = { workspace = true } -sea-orm = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "sqlx-postgres", - "with-chrono", - "mock", -] } +sea-orm = { workspace = true, features = ["macros", "runtime-tokio-rustls", "sqlx-postgres", "with-chrono", "mock"] } serde_json = { workspace = true } solana-client = { workspace = true } solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } spl-account-compression = { workspace = true, features = ["no-entrypoint"] } spl-noop = { workspace = true, features = ["no-entrypoint"] } +sqlx = { workspace = true, features = ["macros", "runtime-tokio-rustls", "postgres", "uuid", "offline", "json"] } thiserror = { workspace = true } -tokio = { workspace = true, features = [ - "fs", - "macros", - "rt-multi-thread", - "sync", - "time", -] } -sqlx = { workspace = true, features = [ - "macros", - "runtime-tokio-rustls", - "postgres", - "uuid", - "offline", - "json", -] } +tokio = { workspace = true, features = ["fs", "macros", "rt-multi-thread", "sync", "time"] } txn_forwarder = { workspace = true } [lints] diff --git a/tools/txn_forwarder/Cargo.toml b/tools/txn_forwarder/Cargo.toml index 9a8388325..c9f5ca999 100644 --- a/tools/txn_forwarder/Cargo.toml +++ b/tools/txn_forwarder/Cargo.toml @@ -23,13 +23,7 @@ solana-client = { workspace = true } solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } thiserror = { workspace = true } -tokio = { workspace = true, features = [ - "macros", - "rt-multi-thread", - "sync", - "time", - "fs", -] } +tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync", "time", "fs"] } tokio-stream = { workspace = true, features = ["io-util"] } [lints] From 9d8031e86e2d6e8610284653c87d28c5fa164a06 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Thu, 23 Nov 2023 17:33:54 -0500 Subject: [PATCH 11/21] remove AccountInfo --- Cargo.lock | 1682 +++++++++++++++++--------------- nft_ingester/Cargo.toml | 2 +- nft_ingester/src/backfiller.rs | 13 +- nft_ingester/src/error/mod.rs | 50 +- 4 files changed, 970 insertions(+), 777 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8a629c27a..730f88db4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,8 +18,8 @@ version = "0.7.12" dependencies = [ "anyhow", "bs58 0.4.0", - "clap 4.4.8", - "env_logger 0.10.0", + "clap 4.5.4", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -93,11 +93,11 @@ dependencies = [ [[package]] name = "ahash" -version = "0.7.6" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", "once_cell", "version_check", ] @@ -109,7 +109,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cd7d5a2cecb58716e47d67d5703a249964b14c7be1ec3cad3affc295b2d1c35d" dependencies = [ "cfg-if", - "getrandom 0.2.10", + "getrandom 0.2.14", "once_cell", "version_check", "zerocopy", @@ -117,9 +117,9 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "1.1.2" +version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" dependencies = [ "memchr", ] @@ -170,7 +170,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7f2a3e1df4685f18d12a943a9f2a7456305401af21a07c9fe076ef9ecd6e400" dependencies = [ "anchor-syn", - "bs58 0.5.0", + "bs58 0.5.1", "proc-macro2", "quote", "syn 1.0.109", @@ -295,7 +295,7 @@ dependencies = [ "bincode", "borsh 0.10.3", "bytemuck", - "getrandom 0.2.10", + "getrandom 0.2.14", "solana-program", "thiserror", ] @@ -307,7 +307,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d9101b84702fed2ea57bd22992f75065da5648017135b844283a2f6d74f27825" dependencies = [ "anyhow", - "bs58 0.5.0", + "bs58 0.5.1", "heck 0.3.3", "proc-macro2", "quote", @@ -344,9 +344,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.4" +version = "0.6.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44" +checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb" dependencies = [ "anstyle", "anstyle-parse", @@ -358,49 +358,49 @@ dependencies = [ [[package]] name = "anstyle" -version = "1.0.4" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87" +checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc" [[package]] name = "anstyle-parse" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140" +checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c" dependencies = [ "utf8parse", ] [[package]] name = "anstyle-query" -version = "1.0.0" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b" +checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "anstyle-wincon" -version = "3.0.1" +version = "3.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628" +checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7" dependencies = [ "anstyle", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "anyhow" -version = "1.0.75" +version = "1.0.82" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6" +checksum = "f538837af36e6f6a9be0faa67f9a314f8119e4e4b5867c6ab40ed60360142519" [[package]] name = "arc-swap" -version = "1.6.0" +version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6" +checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457" [[package]] name = "ark-bn254" @@ -550,7 +550,7 @@ dependencies = [ "num-traits", "rusticata-macros", "thiserror", - "time 0.3.29", + "time 0.3.35", ] [[package]] @@ -605,22 +605,22 @@ dependencies = [ [[package]] name = "async-channel" -version = "2.1.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d37875bd9915b7d67c2f117ea2c30a0989874d0b2cb694fe25403c85763c0c9e" +checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" dependencies = [ "concurrent-queue", - "event-listener 3.1.0", - "event-listener-strategy", + "event-listener 5.3.0", + "event-listener-strategy 0.5.1", "futures-core", "pin-project-lite", ] [[package]] name = "async-compression" -version = "0.4.3" +version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb42b2197bf15ccb092b62c74515dbd8b86d0effd934795f6687c93b6e679a2c" +checksum = "07dbbf24db18d609b1462965249abdf49129ccad073ec257da372adc83259c60" dependencies = [ "brotli", "flate2", @@ -632,30 +632,30 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.7.2" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc5ea910c42e5ab19012bab31f53cb4d63d54c3a27730f9a833a88efcf4bb52d" +checksum = "5f98c37cf288e302c16ef6c8472aad1e034c6c84ce5ea7b8101c98eb4a802fee" dependencies = [ - "async-lock 3.1.1", + "async-lock 3.3.0", "async-task", "concurrent-queue", - "fastrand 2.0.1", - "futures-lite 2.0.1", + "fastrand 2.0.2", + "futures-lite 2.3.0", "slab", ] [[package]] name = "async-global-executor" -version = "2.3.1" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776" +checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c" dependencies = [ - "async-channel 1.9.0", + "async-channel 2.2.0", "async-executor", - "async-io", - "async-lock 2.8.0", + "async-io 2.3.2", + "async-lock 3.3.0", "blocking", - "futures-lite 1.13.0", + "futures-lite 2.3.0", "once_cell", "tokio", ] @@ -673,13 +673,32 @@ dependencies = [ "futures-lite 1.13.0", "log", "parking", - "polling", + "polling 2.8.0", "rustix 0.37.27", "slab", - "socket2 0.4.9", + "socket2 0.4.10", "waker-fn", ] +[[package]] +name = "async-io" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dcccb0f599cfa2f8ace422d3555572f47424da5648a4382a9dd0310ff8210884" +dependencies = [ + "async-lock 3.3.0", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite 2.3.0", + "parking", + "polling 3.6.0", + "rustix 0.38.32", + "slab", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "async-lock" version = "2.8.0" @@ -691,12 +710,12 @@ dependencies = [ [[package]] name = "async-lock" -version = "3.1.1" +version = "3.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "655b9c7fe787d3b25cc0f804a1a8401790f0c5bc395beb5a64dc77d8de079105" +checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b" dependencies = [ - "event-listener 3.1.0", - "event-listener-strategy", + "event-listener 4.0.3", + "event-listener-strategy 0.4.0", "pin-project-lite", ] @@ -718,7 +737,7 @@ dependencies = [ "async-attributes", "async-channel 1.9.0", "async-global-executor", - "async-io", + "async-io 1.13.0", "async-lock 2.8.0", "crossbeam-utils", "futures-channel", @@ -755,24 +774,24 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "async-task" -version = "4.5.0" +version = "4.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4eb2cdb97421e01129ccb49169d8279ed21e829929144f4a22a6e54ac549ca1" +checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799" [[package]] name = "async-trait" -version = "0.1.73" +version = "0.1.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0" +checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -818,17 +837,17 @@ dependencies = [ [[package]] name = "autocfg" -version = "1.1.0" +version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" +checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" [[package]] name = "backon" -version = "0.4.1" +version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c1a6197b2120bb2185a267f6515038558b019e92b832bb0320e96d66268dcf9" +checksum = "d67782c3f868daa71d3533538e98a8e13713231969def7536e8039606fc46bf0" dependencies = [ - "fastrand 1.9.0", + "fastrand 2.0.2", "futures-core", "pin-project", "tokio", @@ -836,9 +855,9 @@ dependencies = [ [[package]] name = "backtrace" -version = "0.3.69" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" dependencies = [ "addr2line", "cc", @@ -876,9 +895,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" [[package]] name = "base64" -version = "0.21.4" +version = "0.21.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" [[package]] name = "base64" @@ -906,7 +925,7 @@ name = "bgtask_creator" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", "futures", "lazy_static", @@ -938,9 +957,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635" +checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1" dependencies = [ "serde", ] @@ -968,9 +987,9 @@ dependencies = [ [[package]] name = "blake3" -version = "1.5.0" +version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0231f06152bf547e9c2b5194f247cd97aacf6dcd8b15d8e5ec0663f64580da87" +checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52" dependencies = [ "arrayref", "arrayvec", @@ -1041,12 +1060,12 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118" dependencies = [ - "async-channel 2.1.0", - "async-lock 3.1.1", + "async-channel 2.2.0", + "async-lock 3.3.0", "async-task", - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-io", - "futures-lite 2.0.1", + "futures-lite 2.3.0", "piper", "tracing", ] @@ -1071,6 +1090,16 @@ dependencies = [ "hashbrown 0.13.2", ] +[[package]] +name = "borsh" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0901fc8eb0aca4c83be0106d6f2db17d86a08dfc2c25f0e84464bf381158add6" +dependencies = [ + "borsh-derive 1.4.0", + "cfg_aliases", +] + [[package]] name = "borsh-derive" version = "0.9.3" @@ -1097,6 +1126,20 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "borsh-derive" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51670c3aa053938b0ee3bd67c3817e471e626151131b934038e83c5bf8de48f5" +dependencies = [ + "once_cell", + "proc-macro-crate 3.1.0", + "proc-macro2", + "quote", + "syn 2.0.58", + "syn_derive", +] + [[package]] name = "borsh-derive-internal" version = "0.9.3" @@ -1143,9 +1186,9 @@ dependencies = [ [[package]] name = "brotli" -version = "3.4.0" +version = "4.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "516074a47ef4bce09577a3b379392300159ce5b1ba2e501ff1c819950066100f" +checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1154,9 +1197,9 @@ dependencies = [ [[package]] name = "brotli-decompressor" -version = "2.5.0" +version = "3.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da74e2b81409b1b743f8f0c62cc6254afefb8b8e50bbfe3735550f7aeefa3448" +checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525" dependencies = [ "alloc-no-stdlib", "alloc-stdlib", @@ -1170,18 +1213,18 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3" [[package]] name = "bs58" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" +checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" dependencies = [ "tinyvec", ] [[package]] name = "bstr" -version = "1.8.0" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "542f33a8835a0884b006a0c3df3dadd99c0c3f296ed26c2fdc8028e01ad6230c" +checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706" dependencies = [ "memchr", "serde", @@ -1189,9 +1232,9 @@ dependencies = [ [[package]] name = "bumpalo" -version = "3.14.0" +version = "3.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" [[package]] name = "bv" @@ -1205,9 +1248,9 @@ dependencies = [ [[package]] name = "bytecheck" -version = "0.6.11" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627" +checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2" dependencies = [ "bytecheck_derive", "ptr_meta", @@ -1216,9 +1259,9 @@ dependencies = [ [[package]] name = "bytecheck_derive" -version = "0.6.11" +version = "0.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61" +checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659" dependencies = [ "proc-macro2", "quote", @@ -1236,13 +1279,13 @@ dependencies = [ [[package]] name = "bytemuck_derive" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "965ab7eb5f8f97d2a083c799f3a1b994fc397b2fe2da5d1da1626ce15a39f2b1" +checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1253,9 +1296,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.5.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" +checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" [[package]] name = "cadence" @@ -1287,9 +1330,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.0.83" +version = "1.0.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +checksum = "2678b2e3449475e95b0aa6f9b506a28e61b3dc8996592b983695e8ebb58a8b41" dependencies = [ "jobserver", "libc", @@ -1301,11 +1344,17 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +[[package]] +name = "cfg_aliases" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" + [[package]] name = "chrono" -version = "0.4.31" +version = "0.4.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" +checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e" dependencies = [ "android-tzdata", "iana-time-zone", @@ -1313,7 +1362,7 @@ dependencies = [ "num-traits", "serde", "wasm-bindgen", - "windows-targets 0.48.5", + "windows-targets 0.52.4", ] [[package]] @@ -1354,29 +1403,29 @@ dependencies = [ "once_cell", "strsim 0.10.0", "termcolor", - "textwrap 0.16.0", + "textwrap 0.16.1", ] [[package]] name = "clap" -version = "4.4.8" +version = "4.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64" +checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0" dependencies = [ "clap_builder", - "clap_derive 4.4.7", + "clap_derive 4.5.4", ] [[package]] name = "clap_builder" -version = "4.4.8" +version = "4.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc" +checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" dependencies = [ "anstream", "anstyle", - "clap_lex 0.6.0", - "strsim 0.10.0", + "clap_lex 0.7.0", + "strsim 0.11.1", ] [[package]] @@ -1394,14 +1443,14 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.4.7" +version = "4.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" +checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64" dependencies = [ - "heck 0.4.1", + "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1415,9 +1464,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.6.0" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" +checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce" [[package]] name = "colorchoice" @@ -1440,9 +1489,9 @@ dependencies = [ [[package]] name = "combine" -version = "4.6.6" +version = "4.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" +checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd" dependencies = [ "bytes", "futures-core", @@ -1454,24 +1503,24 @@ dependencies = [ [[package]] name = "concurrent-queue" -version = "2.3.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f057a694a54f12365049b0958a1685bb52d567f5593b355fbf685838e873d400" +checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363" dependencies = [ "crossbeam-utils", ] [[package]] name = "console" -version = "0.15.7" +version = "0.15.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8" +checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb" dependencies = [ "encode_unicode", "lazy_static", "libc", "unicode-width", - "windows-sys 0.45.0", + "windows-sys 0.52.0", ] [[package]] @@ -1508,9 +1557,9 @@ checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2" [[package]] name = "core-foundation" -version = "0.9.3" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" dependencies = [ "core-foundation-sys", "libc", @@ -1518,95 +1567,85 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.4" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" +checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" [[package]] name = "cpufeatures" -version = "0.2.9" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1" +checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504" dependencies = [ "libc", ] [[package]] name = "crc" -version = "3.0.1" +version = "3.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe" +checksum = "69e6e4d7b33a94f0991c26729976b10ebde1d34c3ee82408fb536164fa10d636" dependencies = [ "crc-catalog", ] [[package]] name = "crc-catalog" -version = "2.2.0" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484" +checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5" [[package]] name = "crc32fast" -version = "1.3.2" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" dependencies = [ "cfg-if", ] [[package]] name = "crossbeam-channel" -version = "0.5.8" +version = "0.5.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200" +checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95" dependencies = [ - "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-deque" -version = "0.8.3" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef" +checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" dependencies = [ - "cfg-if", "crossbeam-epoch", "crossbeam-utils", ] [[package]] name = "crossbeam-epoch" -version = "0.9.15" +version = "0.9.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae211234986c545741a7dc064309f67ee1e5ad243d0e48335adc0484d960bcc7" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" dependencies = [ - "autocfg", - "cfg-if", "crossbeam-utils", - "memoffset 0.9.0", - "scopeguard", ] [[package]] name = "crossbeam-queue" -version = "0.3.8" +version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add" +checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35" dependencies = [ - "cfg-if", "crossbeam-utils", ] [[package]] name = "crossbeam-utils" -version = "0.8.16" +version = "0.8.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" -dependencies = [ - "cfg-if", -] +checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345" [[package]] name = "crunchy" @@ -1659,9 +1698,9 @@ dependencies = [ [[package]] name = "darling" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e" +checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391" dependencies = [ "darling_core", "darling_macro", @@ -1669,27 +1708,27 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621" +checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f" dependencies = [ "fnv", "ident_case", "proc-macro2", "quote", "strsim 0.10.0", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "darling_macro" -version = "0.20.3" +version = "0.20.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5" +checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f" dependencies = [ "darling_core", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1700,7 +1739,7 @@ dependencies = [ "backon", "cadence", "cadence-macros", - "clap 4.4.8", + "clap 4.5.4", "figment", "plerkle_messenger", "solana-account-decoder", @@ -1722,10 +1761,10 @@ dependencies = [ "borsh 0.10.3", "cadence", "cadence-macros", - "clap 4.4.8", + "clap 4.5.4", "das-core", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -1755,7 +1794,7 @@ dependencies = [ "cadence", "cadence-macros", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "figment", "hyper", "jsonrpsee", @@ -1797,17 +1836,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856" dependencies = [ "cfg-if", - "hashbrown 0.14.1", + "hashbrown 0.14.2", "lock_api", "once_cell", - "parking_lot_core 0.9.8", + "parking_lot_core 0.9.9", ] [[package]] name = "data-encoding" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308" +checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" [[package]] name = "der" @@ -1834,10 +1873,11 @@ dependencies = [ [[package]] name = "deranged" -version = "0.3.8" +version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946" +checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" dependencies = [ + "powerfmt", "serde", ] @@ -1953,7 +1993,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1976,7 +2016,7 @@ checksum = "a6cbae11b3de8fce2a456e8ea3dada226b35fe791f0dc1d360c0941f0bb681f3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -1987,9 +2027,9 @@ checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" [[package]] name = "dyn-clone" -version = "1.0.14" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23d2f3407d9a573d666de4b5bdf10569d73ca9478087346697dcbae6244bfbcd" +checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" [[package]] name = "eager" @@ -2034,9 +2074,9 @@ dependencies = [ [[package]] name = "either" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" +checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a" dependencies = [ "serde", ] @@ -2049,31 +2089,31 @@ checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" [[package]] name = "encoding_rs" -version = "0.8.33" +version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" +checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" dependencies = [ "cfg-if", ] [[package]] name = "enum-iterator" -version = "1.4.1" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7add3873b5dd076766ee79c8e406ad1a472c385476b9e38849f8eec24f1be689" +checksum = "9fd242f399be1da0a5354aa462d57b4ab2b4ee0683cc552f7c007d2d12d36e94" dependencies = [ "enum-iterator-derive", ] [[package]] name = "enum-iterator-derive" -version = "1.2.1" +version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eecf8589574ce9b895052fa12d69af7a233f99e6107f5cb8dd1044f2a17bfdcb" +checksum = "03cdc46ec28bd728e67540c528013c6a10eb69a02eb31078a1bda695438cbfb8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -2091,9 +2131,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.10.0" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0" +checksum = "4cd405aab171cb85d6735e5c8d9db038c17d3ca007a4d2c25f337935c3d90580" dependencies = [ "humantime", "is-terminal", @@ -2110,12 +2150,12 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "errno" -version = "0.3.5" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860" +checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -2126,9 +2166,20 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" [[package]] name = "event-listener" -version = "3.1.0" +version = "4.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d93877bcde0eb80ca09131a08d23f0a5c18a620b01db137dba666d18cd9b30c2" +checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e" +dependencies = [ + "concurrent-queue", + "parking", + "pin-project-lite", +] + +[[package]] +name = "event-listener" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9944b8ca13534cdfb2800775f8dd4902ff3fc75a50101466decadfdf322a24" dependencies = [ "concurrent-queue", "parking", @@ -2137,11 +2188,21 @@ dependencies = [ [[package]] name = "event-listener-strategy" -version = "0.3.0" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3" +dependencies = [ + "event-listener 4.0.3", + "pin-project-lite", +] + +[[package]] +name = "event-listener-strategy" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d96b852f1345da36d551b9473fa1e2b1eb5c5195585c6c018118bc92a8d91160" +checksum = "332f51cb23d20b0de8458b86580878211da09bcd4503cb579c225b3d124cabb3" dependencies = [ - "event-listener 3.1.0", + "event-listener 5.3.0", "pin-project-lite", ] @@ -2166,9 +2227,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.0.1" +version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" +checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984" [[package]] name = "feature-probe" @@ -2183,7 +2244,7 @@ dependencies = [ "anyhow", "async-trait", "borsh 0.10.3", - "clap 4.4.8", + "clap 4.5.4", "mpl-bubblegum", "solana-account-decoder", "solana-client", @@ -2194,15 +2255,15 @@ dependencies = [ [[package]] name = "figment" -version = "0.10.11" +version = "0.10.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a014ac935975a70ad13a3bff2463b1c1b083b35ae4cb6309cfc59476aa7a181f" +checksum = "fdefe49ed1057d124dc81a0681c30dd07de56ad96e32adc7b64e8f28eaab31c4" dependencies = [ "atomic 0.6.0", "pear", "serde", "serde_yaml", - "toml 0.8.8", + "toml 0.8.12", "uncased", "version_check", ] @@ -2225,9 +2286,9 @@ dependencies = [ [[package]] name = "flate2" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6c98ee8095e9d1dcbf2fcc6d95acccb90d1c81db1e44725c6a984b1dbdfb010" +checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" dependencies = [ "crc32fast", "miniz_oxide", @@ -2256,9 +2317,9 @@ checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" [[package]] name = "form_urlencoded" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" dependencies = [ "percent-encoding", ] @@ -2292,9 +2353,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" [[package]] name = "futures" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40" +checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" dependencies = [ "futures-channel", "futures-core", @@ -2307,9 +2368,9 @@ dependencies = [ [[package]] name = "futures-channel" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2" +checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" dependencies = [ "futures-core", "futures-sink", @@ -2317,15 +2378,15 @@ dependencies = [ [[package]] name = "futures-core" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c" +checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" [[package]] name = "futures-executor" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0" +checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" dependencies = [ "futures-core", "futures-task", @@ -2345,9 +2406,9 @@ dependencies = [ [[package]] name = "futures-io" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964" +checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" [[package]] name = "futures-lite" @@ -2366,46 +2427,45 @@ dependencies = [ [[package]] name = "futures-lite" -version = "2.0.1" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3831c2651acb5177cbd83943f3d9c8912c5ad03c76afcc0e9511ba568ec5ebb" +checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5" dependencies = [ - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-core", "futures-io", - "memchr", "parking", "pin-project-lite", ] [[package]] name = "futures-macro" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72" +checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "futures-sink" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e" +checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" [[package]] name = "futures-task" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65" +checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" [[package]] name = "futures-util" -version = "0.3.28" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533" +checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" dependencies = [ "futures-channel", "futures-core", @@ -2461,9 +2521,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.10" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" +checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c" dependencies = [ "cfg-if", "js-sys", @@ -2474,21 +2534,21 @@ dependencies = [ [[package]] name = "gimli" -version = "0.28.0" +version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0" +checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" [[package]] name = "globset" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d" +checksum = "57da3b9b5b85bd66f31093f8c408b90a74431672542466497dcbdfdc02034be1" dependencies = [ "aho-corasick", "bstr", - "fnv", "log", - "regex", + "regex-automata 0.4.6", + "regex-syntax 0.8.3", ] [[package]] @@ -2516,9 +2576,9 @@ dependencies = [ [[package]] name = "h2" -version = "0.3.21" +version = "0.3.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833" +checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8" dependencies = [ "bytes", "fnv", @@ -2526,7 +2586,7 @@ dependencies = [ "futures-sink", "futures-util", "http", - "indexmap 1.9.3", + "indexmap 2.2.6", "slab", "tokio", "tokio-util", @@ -2548,7 +2608,7 @@ version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", ] [[package]] @@ -2557,7 +2617,7 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", ] [[package]] @@ -2571,9 +2631,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.14.1" +version = "0.14.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dfda62a12f55daeae5015f81b0baea145391cb4520f86c248fc615d72640d12" +checksum = "f93e7192158dbcda357bdec5fb5788eebf8bbac027f3f33e719d29135ae84156" dependencies = [ "ahash 0.8.5", "allocator-api2", @@ -2585,7 +2645,7 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7" dependencies = [ - "hashbrown 0.14.1", + "hashbrown 0.14.2", ] [[package]] @@ -2623,9 +2683,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.3.3" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" +checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024" [[package]] name = "hex" @@ -2641,9 +2701,9 @@ checksum = "12cb882ccb290b8646e554b157ab0b71e64e8d5bef775cd66b6531e52d302669" [[package]] name = "hkdf" -version = "0.12.3" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" dependencies = [ "hmac 0.12.1", ] @@ -2680,9 +2740,9 @@ dependencies = [ [[package]] name = "http" -version = "0.2.9" +version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" dependencies = [ "bytes", "fnv", @@ -2691,9 +2751,9 @@ dependencies = [ [[package]] name = "http-body" -version = "0.4.5" +version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" +checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" dependencies = [ "bytes", "http", @@ -2726,9 +2786,9 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.27" +version = "0.14.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" +checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" dependencies = [ "bytes", "futures-channel", @@ -2741,7 +2801,7 @@ dependencies = [ "httpdate", "itoa", "pin-project-lite", - "socket2 0.4.9", + "socket2 0.5.6", "tokio", "tower-service", "tracing", @@ -2750,14 +2810,14 @@ dependencies = [ [[package]] name = "hyper-rustls" -version = "0.24.1" +version = "0.24.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" dependencies = [ "futures-util", "http", "hyper", - "rustls 0.21.7", + "rustls 0.21.10", "tokio", "tokio-rustls 0.24.1", ] @@ -2777,16 +2837,16 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.57" +version = "0.1.60" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613" +checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" dependencies = [ "android_system_properties", "core-foundation-sys", "iana-time-zone-haiku", "js-sys", "wasm-bindgen", - "windows", + "windows-core", ] [[package]] @@ -2806,9 +2866,9 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" [[package]] name = "idna" -version = "0.4.0" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c" +checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" dependencies = [ "unicode-bidi", "unicode-normalization", @@ -2843,25 +2903,25 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.0.2" +version = "2.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8adf3ddd720272c6ea8bf59463c04e0f93d0bbf7c5439b691bca2987e0270897" +checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26" dependencies = [ "equivalent", - "hashbrown 0.14.1", + "hashbrown 0.14.2", "serde", ] [[package]] name = "indicatif" -version = "0.17.7" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb28741c9db9a713d93deb3bb9515c20788cef5815265bee4980e87bde7e0f25" +checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3" dependencies = [ "console", "instant", "number_prefix", - "portable-atomic 1.4.3", + "portable-atomic 1.6.0", "unicode-width", ] @@ -2873,16 +2933,15 @@ checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb" [[package]] name = "insta" -version = "1.35.1" +version = "1.38.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c985c1bef99cf13c58fade470483d81a2bfe846ebde60ed28cc2dddec2df9e2" +checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc" dependencies = [ "console", "lazy_static", "linked-hash-map", "serde", "similar", - "yaml-rust", ] [[package]] @@ -2934,26 +2993,26 @@ version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2" dependencies = [ - "hermit-abi 0.3.3", + "hermit-abi 0.3.9", "libc", "windows-sys 0.48.0", ] [[package]] name = "ipnet" -version = "2.8.0" +version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6" +checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" [[package]] name = "is-terminal" -version = "0.4.9" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b" +checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b" dependencies = [ - "hermit-abi 0.3.3", - "rustix 0.38.18", - "windows-sys 0.48.0", + "hermit-abi 0.3.9", + "libc", + "windows-sys 0.52.0", ] [[package]] @@ -2967,33 +3026,33 @@ dependencies = [ [[package]] name = "itertools" -version = "0.11.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" dependencies = [ "either", ] [[package]] name = "itoa" -version = "1.0.9" +version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" +checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" [[package]] name = "jobserver" -version = "0.1.26" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2" +checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6" dependencies = [ "libc", ] [[package]] name = "js-sys" -version = "0.3.64" +version = "0.3.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a" +checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d" dependencies = [ "wasm-bindgen", ] @@ -3114,18 +3173,18 @@ dependencies = [ [[package]] name = "kaigan" -version = "0.2.2" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a26f49495f94a283312e7ef45a243540ef20c9356bb01c8d84a61ac8ba5339b" +checksum = "e623cca1f0e2a0919032c1bdabbf81dd9aa34658d5066aca7bb90d608317ab91" dependencies = [ "borsh 0.10.3", ] [[package]] name = "keccak" -version = "0.1.4" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" +checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" dependencies = [ "cpufeatures", ] @@ -3147,9 +3206,19 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.149" +version = "0.2.153" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b" +checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" + +[[package]] +name = "libredox" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d" +dependencies = [ + "bitflags 2.5.0", + "libc", +] [[package]] name = "libsecp256k1" @@ -3225,9 +3294,9 @@ checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519" [[package]] name = "linux-raw-sys" -version = "0.4.10" +version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f" +checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c" [[package]] name = "load_generation" @@ -3246,9 +3315,9 @@ dependencies = [ [[package]] name = "lock_api" -version = "0.4.10" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16" +checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" dependencies = [ "autocfg", "scopeguard", @@ -3256,9 +3325,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.20" +version = "0.4.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" +checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" dependencies = [ "value-bag", ] @@ -3284,9 +3353,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.6.4" +version = "2.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" +checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d" [[package]] name = "memmap2" @@ -3308,9 +3377,9 @@ dependencies = [ [[package]] name = "memoffset" -version = "0.9.0" +version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" dependencies = [ "autocfg", ] @@ -3343,7 +3412,7 @@ version = "0.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b9b8653cec6897f73b519a43fba5ee3d50f62fe9af80b428accdcc093b4a849" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", "metrics-macros", "portable-atomic 0.3.20", ] @@ -3393,18 +3462,18 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" [[package]] name = "miniz_oxide" -version = "0.7.1" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" +checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7" dependencies = [ "adler", ] [[package]] name = "mio" -version = "0.8.8" +version = "0.8.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2" +checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" dependencies = [ "libc", "wasi 0.11.0+wasi-snapshot-preview1", @@ -3436,22 +3505,22 @@ dependencies = [ "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.6.1", + "serde_with 3.7.0", "solana-program", "thiserror", ] [[package]] name = "mpl-token-metadata" -version = "4.1.1" +version = "4.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4b2de608098eb2ef2a5392069dea83084967e25a4d69d0380a6bb02454fc0fe" +checksum = "caf0f61b553e424a6234af1268456972ee66c2222e1da89079242251fa7479e5" dependencies = [ "borsh 0.10.3", "num-derive 0.3.3", "num-traits", "serde", - "serde_with 3.6.1", + "serde_with 3.7.0", "solana-program", "thiserror", ] @@ -3479,12 +3548,13 @@ name = "nft_ingester" version = "0.7.2" dependencies = [ "async-trait", + "blockbuster", "borsh 0.10.3", "bs58 0.4.0", "cadence", "cadence-macros", "chrono", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", "figment", "flatbuffers", @@ -3592,6 +3662,12 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-conv" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" + [[package]] name = "num-derive" version = "0.3.3" @@ -3605,30 +3681,29 @@ dependencies = [ [[package]] name = "num-derive" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfb77679af88f8b125209d354a202862602672222e7f2313fdd6dc349bad4712" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "num-integer" -version = "0.1.45" +version = "0.1.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" dependencies = [ - "autocfg", "num-traits", ] [[package]] name = "num-iter" -version = "0.1.43" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" +checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9" dependencies = [ "autocfg", "num-integer", @@ -3649,9 +3724,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.17" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a" dependencies = [ "autocfg", ] @@ -3662,7 +3737,7 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi 0.3.3", + "hermit-abi 0.3.9", "libc", ] @@ -3693,7 +3768,7 @@ dependencies = [ "proc-macro-crate 1.3.1", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3702,10 +3777,10 @@ version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b" dependencies = [ - "proc-macro-crate 1.3.1", + "proc-macro-crate 3.1.0", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3716,9 +3791,9 @@ checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" [[package]] name = "object" -version = "0.32.1" +version = "0.32.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0" +checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" dependencies = [ "memchr", ] @@ -3740,9 +3815,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "opaque-debug" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" [[package]] name = "open-rpc-derive" @@ -3770,11 +3845,11 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.57" +version = "0.10.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bac25ee399abb46215765b1cb35bc0212377e58a061560d8b29b024fd0430e7c" +checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.5.0", "cfg-if", "foreign-types", "libc", @@ -3791,7 +3866,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3802,9 +3877,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.93" +version = "0.9.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d" +checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2" dependencies = [ "cc", "libc", @@ -3871,7 +3946,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" dependencies = [ "lock_api", - "parking_lot_core 0.9.8", + "parking_lot_core 0.9.9", ] [[package]] @@ -3890,13 +3965,13 @@ dependencies = [ [[package]] name = "parking_lot_core" -version = "0.9.8" +version = "0.9.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447" +checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" dependencies = [ "cfg-if", "libc", - "redox_syscall 0.3.5", + "redox_syscall 0.4.1", "smallvec", "windows-targets 0.48.5", ] @@ -3927,9 +4002,9 @@ dependencies = [ [[package]] name = "pear" -version = "0.2.7" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61a386cd715229d399604b50d1361683fe687066f42d56f54be995bc6868f71c" +checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467" dependencies = [ "inlinable_string", "pear_codegen", @@ -3938,14 +4013,14 @@ dependencies = [ [[package]] name = "pear_codegen" -version = "0.2.7" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da9f0f13dac8069c139e8300a6510e3f4143ecf5259c60b116a9b271b4ca0d54" +checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147" dependencies = [ "proc-macro2", "proc-macro2-diagnostics", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -3959,9 +4034,9 @@ dependencies = [ [[package]] name = "percent-encoding" -version = "2.3.0" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" [[package]] name = "percentage" @@ -3974,29 +4049,29 @@ dependencies = [ [[package]] name = "pin-project" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0" +checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.1.4" +version = "1.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690" +checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "pin-project-lite" -version = "0.2.13" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" +checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" [[package]] name = "pin-utils" @@ -4011,7 +4086,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4" dependencies = [ "atomic-waker", - "fastrand 2.0.1", + "fastrand 2.0.2", "futures-io", ] @@ -4028,9 +4103,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.27" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964" +checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" [[package]] name = "plain" @@ -4040,9 +4115,9 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" [[package]] name = "plerkle_messenger" -version = "1.6.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2f8e4e8975dcd2dbf94c7f84409096f0a0e5af287eabc9a212704e9e325ec84" +checksum = "a94c75e3178528c45bca0b7d515bdc6a3733b5f67d5b37b8a085cf6d7f81e3f2" dependencies = [ "async-mutex", "async-trait", @@ -4088,6 +4163,21 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "polling" +version = "3.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0c976a60b2d7e99d6f229e414670a9b85d13ac305cc6d1e9c134de58c5aaaf6" +dependencies = [ + "cfg-if", + "concurrent-queue", + "hermit-abi 0.3.9", + "pin-project-lite", + "rustix 0.38.32", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "polyval" version = "0.5.3" @@ -4106,14 +4196,20 @@ version = "0.3.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e30165d31df606f5726b090ec7592c308a0eaf61721ff64c9a3018e344a8753e" dependencies = [ - "portable-atomic 1.4.3", + "portable-atomic 1.6.0", ] [[package]] name = "portable-atomic" -version = "1.4.3" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0" + +[[package]] +name = "powerfmt" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31114a898e107c51bb1609ffaf55a0e011cf6a4d7f1170d0015a165082c0338b" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" [[package]] name = "ppv-lite86" @@ -4140,6 +4236,15 @@ dependencies = [ "toml_edit 0.19.15", ] +[[package]] +name = "proc-macro-crate" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284" +dependencies = [ + "toml_edit 0.21.1", +] + [[package]] name = "proc-macro-error" version = "1.0.4" @@ -4166,9 +4271,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.69" +version = "1.0.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" dependencies = [ "unicode-ident", ] @@ -4181,7 +4286,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "version_check", "yansi", ] @@ -4279,7 +4384,7 @@ checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -4293,7 +4398,7 @@ dependencies = [ "quinn-proto", "quinn-udp", "rustc-hash", - "rustls 0.21.7", + "rustls 0.21.10", "thiserror", "tokio", "tracing", @@ -4309,7 +4414,7 @@ dependencies = [ "rand 0.8.5", "ring 0.16.20", "rustc-hash", - "rustls 0.21.7", + "rustls 0.21.10", "rustls-native-certs", "slab", "thiserror", @@ -4325,16 +4430,16 @@ checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7" dependencies = [ "bytes", "libc", - "socket2 0.5.4", + "socket2 0.5.6", "tracing", "windows-sys 0.48.0", ] [[package]] name = "quote" -version = "1.0.33" +version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" dependencies = [ "proc-macro2", ] @@ -4442,7 +4547,7 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", ] [[package]] @@ -4465,9 +4570,9 @@ dependencies = [ [[package]] name = "rayon" -version = "1.8.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" dependencies = [ "either", "rayon-core", @@ -4475,9 +4580,9 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.12.0" +version = "1.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" +checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" dependencies = [ "crossbeam-deque", "crossbeam-utils", @@ -4491,7 +4596,7 @@ checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b" dependencies = [ "pem", "ring 0.16.20", - "time 0.3.29", + "time 0.3.35", "yasna", ] @@ -4513,7 +4618,7 @@ dependencies = [ "arc-swap", "async-trait", "bytes", - "combine 4.6.6", + "combine 4.6.7", "futures", "futures-util", "itoa", @@ -4539,34 +4644,34 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.3.5" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" +checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" dependencies = [ "bitflags 1.3.2", ] [[package]] name = "redox_users" -version = "0.4.3" +version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" +checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891" dependencies = [ - "getrandom 0.2.10", - "redox_syscall 0.2.16", + "getrandom 0.2.14", + "libredox", "thiserror", ] [[package]] name = "regex" -version = "1.9.6" +version = "1.10.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff" +checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c" dependencies = [ "aho-corasick", "memchr", - "regex-automata 0.3.9", - "regex-syntax 0.7.5", + "regex-automata 0.4.6", + "regex-syntax 0.8.3", ] [[package]] @@ -4580,13 +4685,13 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.3.9" +version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9" +checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea" dependencies = [ "aho-corasick", "memchr", - "regex-syntax 0.7.5", + "regex-syntax 0.8.3", ] [[package]] @@ -4597,27 +4702,27 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" [[package]] name = "regex-syntax" -version = "0.7.5" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da" +checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56" [[package]] name = "rend" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2571463863a6bd50c32f94402933f03457a3fbaf697a707c5be741e459f08fd" +checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c" dependencies = [ "bytecheck", ] [[package]] name = "reqwest" -version = "0.11.22" +version = "0.11.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" dependencies = [ "async-compression", - "base64 0.21.4", + "base64 0.21.7", "bytes", "encoding_rs", "futures-core", @@ -4636,11 +4741,12 @@ dependencies = [ "once_cell", "percent-encoding", "pin-project-lite", - "rustls 0.21.7", + "rustls 0.21.10", "rustls-pemfile", "serde", "serde_json", "serde_urlencoded", + "sync_wrapper", "system-configuration", "tokio", "tokio-native-tls", @@ -4651,7 +4757,7 @@ dependencies = [ "wasm-bindgen", "wasm-bindgen-futures", "web-sys", - "webpki-roots 0.25.2", + "webpki-roots 0.25.4", "winreg", ] @@ -4672,26 +4778,28 @@ dependencies = [ [[package]] name = "ring" -version = "0.17.2" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "911b295d2d302948838c8ac142da1ee09fa7863163b44e6715bc9357905878b8" +checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d" dependencies = [ "cc", - "getrandom 0.2.10", + "cfg-if", + "getrandom 0.2.14", "libc", "spin 0.9.8", "untrusted 0.9.0", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "rkyv" -version = "0.7.42" +version = "0.7.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58" +checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0" dependencies = [ "bitvec", "bytecheck", + "bytes", "hashbrown 0.12.3", "ptr_meta", "rend", @@ -4703,9 +4811,9 @@ dependencies = [ [[package]] name = "rkyv_derive" -version = "0.7.42" +version = "0.7.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2e06b915b5c230a17d7a736d1e2e63ee753c256a8614ef3f5147b13a4f5541d" +checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65" dependencies = [ "proc-macro2", "quote", @@ -4748,12 +4856,12 @@ dependencies = [ [[package]] name = "rust_decimal" -version = "1.32.0" +version = "1.35.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4c4216490d5a413bc6d10fa4742bd7d4955941d062c0ef873141d6b0e7b30fd" +checksum = "1790d1c4c0ca81211399e0e0af16333276f375209e71a37b67698a373db5b47a" dependencies = [ "arrayvec", - "borsh 0.10.3", + "borsh 1.4.0", "bytes", "num-traits", "rand 0.8.5", @@ -4776,9 +4884,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" [[package]] name = "rustc-serialize" -version = "0.3.24" +version = "0.3.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda" +checksum = "fe834bc780604f4674073badbad26d7219cadfb4a2275802db12cbae17498401" [[package]] name = "rustc_version" @@ -4814,15 +4922,15 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.18" +version = "0.38.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a74ee2d7c2581cd139b42447d7d9389b889bdaad3a73f1ebb16f2a3237bb19c" +checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.5.0", "errno", "libc", - "linux-raw-sys 0.4.10", - "windows-sys 0.48.0", + "linux-raw-sys 0.4.13", + "windows-sys 0.52.0", ] [[package]] @@ -4839,12 +4947,12 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.7" +version = "0.21.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8" +checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba" dependencies = [ "log", - "ring 0.16.20", + "ring 0.17.8", "rustls-webpki", "sct", ] @@ -4863,49 +4971,49 @@ dependencies = [ [[package]] name = "rustls-pemfile" -version = "1.0.3" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d3987094b1d07b653b7dfdc3f70ce9a1da9c51ac18c1b06b662e4f9a0e9f4b2" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", ] [[package]] name = "rustls-webpki" -version = "0.101.6" +version = "0.101.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c7d5dece342910d9ba34d259310cae3e0154b873b35408b787b59bce53d34fe" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" dependencies = [ - "ring 0.16.20", - "untrusted 0.7.1", + "ring 0.17.8", + "untrusted 0.9.0", ] [[package]] name = "rustversion" -version = "1.0.14" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" +checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47" [[package]] name = "ryu" -version = "1.0.15" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741" +checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1" [[package]] name = "schannel" -version = "0.1.22" +version = "0.1.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88" +checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] name = "schemars" -version = "0.8.15" +version = "0.8.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c" +checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29" dependencies = [ "dyn-clone", "schemars_derive", @@ -4915,9 +5023,9 @@ dependencies = [ [[package]] name = "schemars_derive" -version = "0.8.15" +version = "0.8.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c" +checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967" dependencies = [ "proc-macro2", "quote", @@ -4948,17 +5056,17 @@ checksum = "1db149f81d46d2deba7cd3c50772474707729550221e69588478ebf9ada425ae" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "sct" -version = "0.7.0" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" dependencies = [ - "ring 0.16.20", - "untrusted 0.7.1", + "ring 0.17.8", + "untrusted 0.9.0", ] [[package]] @@ -4983,7 +5091,7 @@ dependencies = [ "serde_json", "sqlx", "thiserror", - "time 0.3.29", + "time 0.3.35", "tracing", "url", "uuid", @@ -5044,7 +5152,7 @@ dependencies = [ "rust_decimal", "sea-query-derive 0.2.0", "serde_json", - "time 0.3.29", + "time 0.3.35", "uuid", ] @@ -5068,7 +5176,7 @@ dependencies = [ "sea-query 0.27.2", "serde_json", "sqlx", - "time 0.3.29", + "time 0.3.35", "uuid", ] @@ -5151,9 +5259,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" [[package]] name = "security-framework" -version = "2.9.2" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de" +checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6" dependencies = [ "bitflags 1.3.2", "core-foundation", @@ -5164,9 +5272,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.9.1" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a" +checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef" dependencies = [ "core-foundation-sys", "libc", @@ -5174,37 +5282,37 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.19" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad977052201c6de01a8ef2aa3378c4bd23217a056337d1d6da40468d267a4fb0" +checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" [[package]] name = "serde" -version = "1.0.188" +version = "1.0.197" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e" +checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2" dependencies = [ "serde_derive", ] [[package]] name = "serde_bytes" -version = "0.11.12" +version = "0.11.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab33ec92f677585af6d88c65593ae2375adde54efdbf16d597f2cbc7a6d368ff" +checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734" dependencies = [ "serde", ] [[package]] name = "serde_derive" -version = "1.0.188" +version = "1.0.197" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2" +checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -5220,11 +5328,11 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.107" +version = "1.0.115" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65" +checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "itoa", "ryu", "serde", @@ -5232,9 +5340,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "0.6.4" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12022b835073e5b11e90a14f86838ceb1c8fb0325b72416845c487ac0fa95e80" +checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1" dependencies = [ "serde", ] @@ -5263,20 +5371,20 @@ dependencies = [ [[package]] name = "serde_with" -version = "3.6.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15d167997bd841ec232f5b2b8e0e26606df2e7caa4c31b95ea9ca52b200bd270" +checksum = "ee80b0e361bbf88fd2f6e242ccd19cfda072cb0faa6ae694ecee08199938569a" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "chrono", "hex", "indexmap 1.9.3", - "indexmap 2.0.2", + "indexmap 2.2.6", "serde", "serde_derive", "serde_json", - "serde_with_macros 3.6.1", - "time 0.3.29", + "serde_with_macros 3.7.0", + "time 0.3.35", ] [[package]] @@ -5288,28 +5396,28 @@ dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "serde_with_macros" -version = "3.6.1" +version = "3.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "865f9743393e638991566a8b7a479043c2c8da94a33e0a31f18214c9cae0a64d" +checksum = "6561dc161a9224638a31d876ccdfefbc1df91d3f3a8342eddb35f055d48c7655" dependencies = [ "darling", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "serde_yaml" -version = "0.9.25" +version = "0.9.34+deprecated" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a49e178e4452f45cb61d0cd8cebc1b0fafd3e41929e996cef79aa3aca91f574" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "itoa", "ryu", "serde", @@ -5338,7 +5446,7 @@ checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -5455,9 +5563,9 @@ checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a" [[package]] name = "similar" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21" +checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640" [[package]] name = "sized-chunks" @@ -5480,15 +5588,15 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.11.1" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" [[package]] name = "socket2" -version = "0.4.9" +version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662" +checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d" dependencies = [ "libc", "winapi", @@ -5496,12 +5604,12 @@ dependencies = [ [[package]] name = "socket2" -version = "0.5.4" +version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e" +checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.52.0", ] [[package]] @@ -5522,12 +5630,12 @@ dependencies = [ [[package]] name = "solana-account-decoder" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d76c43ef61f527d719b5c6bfa5a62ebba60839739125da9e8a00fb82349afd2" +checksum = "d145d4e1e33bfecd209059a0c4c75d623dbcaeb565b4c197f1815257be45726a" dependencies = [ "Inflector", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bs58 0.4.0", "bv", @@ -5547,9 +5655,9 @@ dependencies = [ [[package]] name = "solana-clap-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb19b9bbd92eee2d8f637026559a9fb48bd98aba534caedf070498a50c91fce8" +checksum = "1deaf83f98be3ba9ecee057efa5cdfa6112267e5b1ff53c4ef4b727f66090b9a" dependencies = [ "chrono", "clap 2.34.0", @@ -5564,16 +5672,16 @@ dependencies = [ [[package]] name = "solana-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9538e3db584a8b1e70060f1f24222b8e0429f18b607f531fb45eb826f4917265" +checksum = "2a8912026a203ff0d90973e7363f141c6ce569484e06ee0a6f72992144263136" dependencies = [ "async-trait", "bincode", "dashmap 4.0.2", "futures", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "indicatif", "log", "quinn", @@ -5597,9 +5705,9 @@ dependencies = [ [[package]] name = "solana-config-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3afd4e309d304e296765cab716fb1fd66c66ec300465c8b26f8cce763275132" +checksum = "4000f4717f86c5f9e1105378e3a6521db770d0ad68417f59960ca4b51103fcd0" dependencies = [ "bincode", "chrono", @@ -5611,15 +5719,15 @@ dependencies = [ [[package]] name = "solana-connection-cache" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92716758e8c0e1c0bc2a5ac2eb3df443a0337fd3991cd38a3b02b12c3fbd18ce" +checksum = "f8b1a4d67c01e5c4464ed9bffb656dec2c88e9bfd7d45bf754f650150e5d81db" dependencies = [ "async-trait", "bincode", "crossbeam-channel", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "log", "rand 0.8.5", "rayon", @@ -5633,9 +5741,9 @@ dependencies = [ [[package]] name = "solana-frozen-abi" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb1b8230474ae9f7c841060c299999124582e8d2a0448d7847720792e98cc64e" +checksum = "1790013c7969353000c22907fc21610adb3389a7c9a27a386ebe7fb32b2ad307" dependencies = [ "ahash 0.8.5", "blake3", @@ -5663,21 +5771,21 @@ dependencies = [ [[package]] name = "solana-frozen-abi-macro" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793910ab733b113b80c357f8f492dda2fabd5671c4ea03db3aa4e46b938fdbe3" +checksum = "a3ed2b49a3dd03ddd5107d6e629e8e5895724227a057b3511bf0c107c6d48308" dependencies = [ "proc-macro2", "quote", "rustc_version", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "solana-logger" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d3f819af39632dc538a566c937253bf46256e4c0e60f621c6db448bc7c76294" +checksum = "bfc0d5b4f046d07e845b69178989a6b3bf168a82eeee006adb77391b339bce64" dependencies = [ "env_logger 0.9.3", "lazy_static", @@ -5686,9 +5794,9 @@ dependencies = [ [[package]] name = "solana-measure" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb045f0235b16f7d926f6e0338db822747d61559a1368c3cb017ba6e02c516d0" +checksum = "857178177c6b378bcfc35df6867a6eef211059f5e4ab01ee87355d6b7493b556" dependencies = [ "log", "solana-sdk", @@ -5696,9 +5804,9 @@ dependencies = [ [[package]] name = "solana-metrics" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1af84362ad5804dc64ca88b1ca5c35bd41321e12d42c798ac06a6fbb60dd0e70" +checksum = "1c68f5cbfbafd002b4d94728748f632a3bd27772ca5c7139710d65940c95477c" dependencies = [ "crossbeam-channel", "gethostname", @@ -5711,9 +5819,9 @@ dependencies = [ [[package]] name = "solana-net-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8e640a95d317cad1322015c5a2b6a71697fd8dabebcb8dd33ed7f5a22869d12" +checksum = "8ce93c50199f077df9d8fd4a82bbdfe654422e1d21e5eecb7f878c4e0078f92f" dependencies = [ "bincode", "clap 3.2.25", @@ -5723,7 +5831,7 @@ dependencies = [ "rand 0.8.5", "serde", "serde_derive", - "socket2 0.5.4", + "socket2 0.5.6", "solana-logger", "solana-sdk", "solana-version", @@ -5733,9 +5841,9 @@ dependencies = [ [[package]] name = "solana-perf" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4266c4bd46620a925b8d508c26578d5559e97fcff6735fd22e39f369c3996ee1" +checksum = "2a233bc2032f4b3f462fe13325cd1a336f355e1d9e793faada488db409cec0d6" dependencies = [ "ahash 0.8.5", "bincode", @@ -5762,17 +5870,17 @@ dependencies = [ [[package]] name = "solana-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "581f38a870bffbe623d900c68579984671f8dfa35bbfb3309d7134de22ce8652" +checksum = "4b2ae4ec9dd6fc76202c94d23942da3cf624325a178e1b0125e70db90b8d7f15" dependencies = [ "ark-bn254", "ark-ec", "ark-ff", "ark-serialize", - "base64 0.21.4", + "base64 0.21.7", "bincode", - "bitflags 2.4.0", + "bitflags 2.5.0", "blake3", "borsh 0.10.3", "borsh 0.9.3", @@ -5783,7 +5891,7 @@ dependencies = [ "console_error_panic_hook", "console_log", "curve25519-dalek", - "getrandom 0.2.10", + "getrandom 0.2.14", "itertools 0.10.5", "js-sys", "lazy_static", @@ -5791,7 +5899,7 @@ dependencies = [ "libsecp256k1", "light-poseidon", "log", - "memoffset 0.9.0", + "memoffset 0.9.1", "num-bigint 0.4.4", "num-derive 0.3.3", "num-traits", @@ -5816,11 +5924,11 @@ dependencies = [ [[package]] name = "solana-program-runtime" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "490b6f65aced077e0c5e57c20f151a134458fc350905c20d7dcf3f2162eaa6f6" +checksum = "b50a6da7b501117f68ef51fc113d771b52af646dc42c43af23a85e32461d59c9" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "bincode", "eager", "enum-iterator", @@ -5844,9 +5952,9 @@ dependencies = [ [[package]] name = "solana-pubsub-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0dc2b26a7a9860f180ce11f69b0ff2a8bea0d4b9e97daee741b1e76565b3c82" +checksum = "bf920143eb7d5bd5f2ea8fc6ab8a1f521512dfe50af7833af40d7cbae83d955d" dependencies = [ "crossbeam-channel", "futures-util", @@ -5869,9 +5977,9 @@ dependencies = [ [[package]] name = "solana-quic-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "727474945d51be37ffe03e7b1d6c9630da41228c7b298a8f45098c203a78ac89" +checksum = "627491c0afd615efb2538c8a49948663ac01aadf99a3cfebb0a63e2b9431ed79" dependencies = [ "async-mutex", "async-trait", @@ -5882,7 +5990,7 @@ dependencies = [ "quinn", "quinn-proto", "rcgen", - "rustls 0.21.7", + "rustls 0.21.10", "solana-connection-cache", "solana-measure", "solana-metrics", @@ -5896,9 +6004,9 @@ dependencies = [ [[package]] name = "solana-rayon-threadlimit" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "853794cccf3bd1984419a594040dfed19666e5a9ad33b0906d4174bc394b22af" +checksum = "4d5c306f32e26031c043c218a0ba3cde08cbb0e08511ab8a4128445d92a535e0" dependencies = [ "lazy_static", "num_cpus", @@ -5906,9 +6014,9 @@ dependencies = [ [[package]] name = "solana-remote-wallet" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b368f270526a5f92ec47c45a6b74ac304b62b08c169b45cf91e0d2f1703889bd" +checksum = "f1c9dbb8cca1b917a01979a1ca98b682f6123df56f11a5227a37c36494ad7740" dependencies = [ "console", "dialoguer", @@ -5925,12 +6033,12 @@ dependencies = [ [[package]] name = "solana-rpc-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71b766876b0c56950ab530d8495ef7eeaeb79e162f03dadaffc0d6852de9e844" +checksum = "2edc8c0f26561e770f28edb9d456221a5554ee90eeb9052ed38942dbb31c035b" dependencies = [ "async-trait", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bs58 0.4.0", "indicatif", @@ -5951,11 +6059,11 @@ dependencies = [ [[package]] name = "solana-rpc-client-api" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "876b2e410cc2403ea3216893f05034b02a180431100eb831d0b67b14fca4d29f" +checksum = "5ff63ab63805a6302ec21284a1138daf5478020f79641d77e53bb84f16c1f5a6" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "bs58 0.4.0", "jsonrpc-core", "reqwest", @@ -5973,9 +6081,9 @@ dependencies = [ [[package]] name = "solana-rpc-client-nonce-utils" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebdb3f02fb3cce3c967f718bc77b79433c24aa801b63dc70f374e8759b2424e4" +checksum = "897db0c1085b8a99ca35871132b6dc6dca3eff68d9210fcd168ccc2e3843dc26" dependencies = [ "clap 2.34.0", "solana-clap-utils", @@ -5986,14 +6094,14 @@ dependencies = [ [[package]] name = "solana-sdk" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d70ab837cc79ed67df6fdb145f1ffd544f1eaa60b0757b750f4864b90498bad" +checksum = "368430d6c9f033e86f8f590d19232d10986d1188c3ad3a6836628d2acc09c21a" dependencies = [ "assert_matches", - "base64 0.21.4", + "base64 0.21.7", "bincode", - "bitflags 2.4.0", + "bitflags 2.5.0", "borsh 0.10.3", "bs58 0.4.0", "bytemuck", @@ -6040,15 +6148,15 @@ dependencies = [ [[package]] name = "solana-sdk-macro" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f9d0433c4084a3260a32ec67f6b4272c4232d15e732be542cd5dfdf0ae1e784" +checksum = "f554d2a144bb0138cfdeced9961cc8a09aaa09f0c3c9a63bd10da41c4a06d420" dependencies = [ "bs58 0.4.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6059,16 +6167,16 @@ checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183" [[package]] name = "solana-streamer" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d70eda40efb5bc57ad50b1ac8452485065c1adae0e701a0348b397db054e2ab5" +checksum = "e28e8941bc0b137f851626ff4d4ce9ebcf9be10619b48d2ed83cd1953af21821" dependencies = [ "async-channel 1.9.0", "bytes", "crossbeam-channel", "futures-util", "histogram", - "indexmap 2.0.2", + "indexmap 2.2.6", "itertools 0.10.5", "libc", "log", @@ -6080,7 +6188,7 @@ dependencies = [ "quinn-proto", "rand 0.8.5", "rcgen", - "rustls 0.21.7", + "rustls 0.21.10", "solana-metrics", "solana-perf", "solana-sdk", @@ -6091,9 +6199,9 @@ dependencies = [ [[package]] name = "solana-thin-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca3c510144695c3d1ee1f84dd9975af7f7d35c168447c484bbd35c21e903c515" +checksum = "760b94e2875b54350f786c85faf50fa1a9a37ae46e9897215d19b373fc2f58cd" dependencies = [ "bincode", "log", @@ -6106,14 +6214,14 @@ dependencies = [ [[package]] name = "solana-tpu-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44f27c8fec609179a7dfc287060df2a926c8cd89329235c4b8d78bd019a72462" +checksum = "7cfdc7ff6cdc1512661de1f9f40723f88dc1e94c8b8938bd537f3713239173e2" dependencies = [ "async-trait", "bincode", "futures-util", - "indexmap 2.0.2", + "indexmap 2.2.6", "indicatif", "log", "rayon", @@ -6130,12 +6238,12 @@ dependencies = [ [[package]] name = "solana-transaction-status" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29f58f2f864d900eddf2e21a99ebe445b6be525d597e44952f075d8237035b8e" +checksum = "ba7131d11c8d5a068bfc26a9dc8c9ee0d77eaf60856dd0c8be880542fc5fbbd6" dependencies = [ "Inflector", - "base64 0.21.4", + "base64 0.21.7", "bincode", "borsh 0.10.3", "bs58 0.4.0", @@ -6155,9 +6263,9 @@ dependencies = [ [[package]] name = "solana-udp-client" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "27ead118c5d549e4345dc59cbc5d9b282164f3e5334707f186e3aa10d40e3b30" +checksum = "54647340d7fa1708c217cbc2411259c5b3784c2df55c1eb4353aca296635ed87" dependencies = [ "async-trait", "solana-connection-cache", @@ -6170,9 +6278,9 @@ dependencies = [ [[package]] name = "solana-version" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "532f5d631562587facc5fe88abd2e31c0d1f29012b6766c664db9f05a39fb05b" +checksum = "1de7a6bad7dff1c595be2eec0c3800a482c6068f3c87c6df87ed091b4e6e642e" dependencies = [ "log", "rustc_version", @@ -6186,9 +6294,9 @@ dependencies = [ [[package]] name = "solana-vote-program" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c684430058b0a2e733936a8851c8843a3a6316ccd5c969d39411a479d6489642" +checksum = "3c828d118d1f135baacfbf51412c4f1ac18af19fdbee43b002d2908e69cdf50b" dependencies = [ "bincode", "log", @@ -6208,12 +6316,12 @@ dependencies = [ [[package]] name = "solana-zk-token-sdk" -version = "1.17.28" +version = "1.17.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aef1b48d9fdb2619349d2d15942d83c99aabe995ff945d9b418176373aa823c" +checksum = "112944743b08f7e1101368ff6d84745e7b4abb075fabaccc02e01bd3ce4b6d6c" dependencies = [ "aes-gcm-siv", - "base64 0.21.4", + "base64 0.21.7", "bincode", "bytemuck", "byteorder", @@ -6296,7 +6404,7 @@ checksum = "992d9c64c2564cc8f63a4b508bf3ebcdf2254b0429b13cd1d31adb6162432a5f" dependencies = [ "assert_matches", "borsh 0.10.3", - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "solana-program", "spl-token", @@ -6317,9 +6425,9 @@ dependencies = [ [[package]] name = "spl-discriminator" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cce5d563b58ef1bb2cdbbfe0dfb9ffdc24903b10ae6a4df2d8f425ece375033f" +checksum = "daa600f2fe56f32e923261719bae640d873edadbc5237681a39b8e37bfd4d263" dependencies = [ "bytemuck", "solana-program", @@ -6328,25 +6436,25 @@ dependencies = [ [[package]] name = "spl-discriminator-derive" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fadbefec4f3c678215ca72bd71862697bb06b41fd77c0088902dd3203354387b" +checksum = "07fd7858fc4ff8fb0e34090e41d7eb06a823e1057945c26d480bfc21d2338a93" dependencies = [ "quote", "spl-discriminator-syn", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "spl-discriminator-syn" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e5f2044ca42c8938d54d1255ce599c79a1ffd86b677dfab695caa20f9ffc3f2" +checksum = "18fea7be851bd98d10721782ea958097c03a0c2a07d8d4997041d0ece6319a63" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.38", + "syn 2.0.58", "thiserror", ] @@ -6370,11 +6478,11 @@ dependencies = [ [[package]] name = "spl-pod" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2881dddfca792737c0706fa0175345ab282b1b0879c7d877bad129645737c079" +checksum = "85a5db7e4efb1107b0b8e52a13f035437cdcb36ef99c58f6d467f089d9b2915a" dependencies = [ - "base64 0.21.4", + "base64 0.21.7", "borsh 0.10.3", "bytemuck", "serde", @@ -6385,11 +6493,11 @@ dependencies = [ [[package]] name = "spl-program-error" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "249e0318493b6bcf27ae9902600566c689b7dfba9f1bdff5893e92253374e78c" +checksum = "7e0657b6490196971d9e729520ba934911ff41fbb2cb9004463dbe23cf8b4b4f" dependencies = [ - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "solana-program", "spl-program-error-derive", @@ -6398,14 +6506,14 @@ dependencies = [ [[package]] name = "spl-program-error-derive" -version = "0.3.1" +version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab5269c8e868da17b6552ef35a51355a017bd8e0eae269c201fef830d35fa52c" +checksum = "1845dfe71fd68f70382232742e758557afe973ae19e6c06807b2c30f5d5cb474" dependencies = [ "proc-macro2", "quote", "sha2 0.10.8", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6445,7 +6553,7 @@ checksum = "d697fac19fd74ff472dfcc13f0b442dd71403178ce1de7b5d16f83a33561c059" dependencies = [ "arrayref", "bytemuck", - "num-derive 0.4.1", + "num-derive 0.4.2", "num-traits", "num_enum 0.7.2", "solana-program", @@ -6506,9 +6614,9 @@ dependencies = [ [[package]] name = "spl-type-length-value" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a468e6f6371f9c69aae760186ea9f1a01c2908351b06a5e0026d21cfc4d7ecac" +checksum = "8f9ebd75d29c5f48de5f6a9c114e08531030b75b8ac2c557600ac7da0b73b1e8" dependencies = [ "bytemuck", "solana-program", @@ -6519,11 +6627,11 @@ dependencies = [ [[package]] name = "sqlformat" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b7b278788e7be4d0d29c0f39497a0eef3fba6bbc8e70d8bf7fde46edeaa9e85" +checksum = "ce81b7bd7c4493975347ef60d8c7e8b742d4694f4c49f93e0a12ea263938176c" dependencies = [ - "itertools 0.11.0", + "itertools 0.12.1", "nom", "unicode_categories", ] @@ -6544,7 +6652,7 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fa8241483a83a3f33aa5fff7e7d9def398ff9990b2752b6c6112b83c6d246029" dependencies = [ - "ahash 0.7.6", + "ahash 0.7.8", "atoi", "base64 0.13.1", "bitflags 1.3.2", @@ -6588,7 +6696,7 @@ dependencies = [ "sqlx-rt", "stringprep", "thiserror", - "time 0.3.29", + "time 0.3.35", "tokio-stream", "url", "uuid", @@ -6642,7 +6750,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6bcb902b974bc20b50c3ad3148022a366a46c9a676b587684ff46c237a3329e" dependencies = [ "async-channel 1.9.0", - "async-io", + "async-io 1.13.0", "atomic 0.5.3", "crossbeam-channel", "futures", @@ -6677,6 +6785,12 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + [[package]] name = "subtle" version = "2.4.1" @@ -6696,15 +6810,33 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.38" +version = "2.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b" +checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687" dependencies = [ "proc-macro2", "quote", "unicode-ident", ] +[[package]] +name = "syn_derive" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1329189c02ff984e9736652b1631330da25eaa6bc639089ed4915d25446cbe7b" +dependencies = [ + "proc-macro-error", + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + [[package]] name = "synstructure" version = "0.12.6" @@ -6746,22 +6878,21 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" [[package]] name = "tempfile" -version = "3.8.0" +version = "3.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef" +checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1" dependencies = [ "cfg-if", - "fastrand 2.0.1", - "redox_syscall 0.3.5", - "rustix 0.38.18", - "windows-sys 0.48.0", + "fastrand 2.0.2", + "rustix 0.38.32", + "windows-sys 0.52.0", ] [[package]] name = "termcolor" -version = "1.3.0" +version = "1.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6093bad37da69aab9d123a8091e4be0aa4a03e4d601ec641c327398315f62b64" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" dependencies = [ "winapi-util", ] @@ -6777,35 +6908,35 @@ dependencies = [ [[package]] name = "textwrap" -version = "0.16.0" +version = "0.16.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d" +checksum = "23d434d3f8967a09480fb04132ebe0a3e088c173e6d0ee7897abbdf4eab0f8b9" [[package]] name = "thiserror" -version = "1.0.49" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4" +checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.49" +version = "1.0.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc" +checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "thread_local" -version = "1.1.7" +version = "1.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152" +checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c" dependencies = [ "cfg-if", "once_cell", @@ -6824,12 +6955,14 @@ dependencies = [ [[package]] name = "time" -version = "0.3.29" +version = "0.3.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "426f806f4089c493dcac0d24c29c01e2c38baf8e30f1b716ee37e83d200b18fe" +checksum = "ef89ece63debf11bc32d1ed8d078ac870cbeb44da02afb02a9ff135ae7ca0582" dependencies = [ "deranged", "itoa", + "num-conv", + "powerfmt", "serde", "time-core", "time-macros", @@ -6843,10 +6976,11 @@ checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" [[package]] name = "time-macros" -version = "0.2.15" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ad70d68dba9e1f8aceda7aa6711965dfec1cac869f311a51bd08b3a2ccbce20" +checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" dependencies = [ + "num-conv", "time-core", ] @@ -6886,9 +7020,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.33.0" +version = "1.37.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653" +checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787" dependencies = [ "backtrace", "bytes", @@ -6898,7 +7032,7 @@ dependencies = [ "parking_lot 0.12.1", "pin-project-lite", "signal-hook-registry", - "socket2 0.5.4", + "socket2 0.5.6", "tokio-macros", "tracing", "windows-sys 0.48.0", @@ -6906,13 +7040,13 @@ dependencies = [ [[package]] name = "tokio-macros" -version = "2.1.0" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e" +checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -6942,15 +7076,15 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ - "rustls 0.21.7", + "rustls 0.21.10", "tokio", ] [[package]] name = "tokio-stream" -version = "0.1.14" +version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842" +checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af" dependencies = [ "futures-core", "pin-project-lite", @@ -6965,18 +7099,18 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" dependencies = [ "futures-util", "log", - "rustls 0.21.7", + "rustls 0.21.10", "tokio", "tokio-rustls 0.24.1", "tungstenite", - "webpki-roots 0.25.2", + "webpki-roots 0.25.4", ] [[package]] name = "tokio-util" -version = "0.7.9" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d" +checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" dependencies = [ "bytes", "futures-core", @@ -6998,14 +7132,14 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.8" +version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1a195ec8c9da26928f773888e0742ca3ca1040c6cd859c919c9f59c1954ab35" +checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3" dependencies = [ "serde", "serde_spanned", "toml_datetime", - "toml_edit 0.21.0", + "toml_edit 0.22.9", ] [[package]] @@ -7023,22 +7157,33 @@ version = "0.19.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", "toml_datetime", - "winnow", + "winnow 0.5.40", ] [[package]] name = "toml_edit" -version = "0.21.0" +version = "0.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d34d383cd00a163b4a5b85053df514d45bc330f6de7737edfe0a93311d1eaa03" +checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" dependencies = [ - "indexmap 2.0.2", + "indexmap 2.2.6", + "toml_datetime", + "winnow 0.5.40", +] + +[[package]] +name = "toml_edit" +version = "0.22.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e40bb779c5187258fd7aad0eb68cb8706a0a81fa712fbea808ab43c4b8374c4" +dependencies = [ + "indexmap 2.2.6", "serde", "serde_spanned", "toml_datetime", - "winnow", + "winnow 0.6.5", ] [[package]] @@ -7084,11 +7229,10 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" [[package]] name = "tracing" -version = "0.1.37" +version = "0.1.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" dependencies = [ - "cfg-if", "log", "pin-project-lite", "tracing-attributes", @@ -7097,20 +7241,20 @@ dependencies = [ [[package]] name = "tracing-attributes" -version = "0.1.26" +version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab" +checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] name = "tracing-core" -version = "0.1.31" +version = "0.1.32" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a" +checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" dependencies = [ "once_cell", "valuable", @@ -7165,9 +7309,9 @@ dependencies = [ "anchor-client", "anyhow", "bs58 0.4.0", - "clap 4.4.8", + "clap 4.5.4", "digital_asset_types", - "env_logger 0.10.0", + "env_logger 0.10.2", "flatbuffers", "futures", "hex", @@ -7189,9 +7333,9 @@ dependencies = [ [[package]] name = "triomphe" -version = "0.1.9" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee8098afad3fb0c54a9007aab6804558410503ad676d4633f9c2559a00ac0f" +checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3" dependencies = [ "serde", "stable_deref_trait", @@ -7199,9 +7343,9 @@ dependencies = [ [[package]] name = "try-lock" -version = "0.2.4" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" [[package]] name = "tungstenite" @@ -7216,7 +7360,7 @@ dependencies = [ "httparse", "log", "rand 0.8.5", - "rustls 0.21.7", + "rustls 0.21.10", "sha1", "thiserror", "url", @@ -7229,8 +7373,8 @@ name = "txn_forwarder" version = "0.7.12" dependencies = [ "anyhow", - "clap 4.4.8", - "env_logger 0.10.0", + "clap 4.5.4", + "env_logger 0.10.2", "figment", "flatbuffers", "futures", @@ -7257,9 +7401,9 @@ checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" [[package]] name = "uncased" -version = "0.9.9" +version = "0.9.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b9bc53168a4be7402ab86c3aad243a84dd7381d09be0eddc81280c1da95ca68" +checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697" dependencies = [ "version_check", ] @@ -7275,9 +7419,9 @@ dependencies = [ [[package]] name = "unicode-bidi" -version = "0.3.13" +version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460" +checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" [[package]] name = "unicode-ident" @@ -7287,18 +7431,18 @@ checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" [[package]] name = "unicode-normalization" -version = "0.1.22" +version = "0.1.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" +checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.10.1" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36" +checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202" [[package]] name = "unicode-width" @@ -7339,9 +7483,9 @@ dependencies = [ [[package]] name = "unsafe-libyaml" -version = "0.2.9" +version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f28467d3e1d3c6586d8f25fa243f544f5800fec42d97032474e17222c2b75cfa" +checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861" [[package]] name = "untrusted" @@ -7367,9 +7511,9 @@ dependencies = [ [[package]] name = "url" -version = "2.4.1" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5" +checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" dependencies = [ "form_urlencoded", "idna", @@ -7390,11 +7534,11 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" [[package]] name = "uuid" -version = "1.4.1" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d" +checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0" dependencies = [ - "getrandom 0.2.10", + "getrandom 0.2.14", "serde", ] @@ -7406,9 +7550,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" [[package]] name = "value-bag" -version = "1.4.2" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a72e1902dde2bd6441347de2b70b7f5d59bf157c6c62f0c44572607a1d55bbe" +checksum = "74797339c3b98616c009c7c3eb53a0ce41e85c8ec66bd3db96ed132d20cfdee8" [[package]] name = "vcpkg" @@ -7467,11 +7611,17 @@ version = "0.11.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" +[[package]] +name = "wasite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b" + [[package]] name = "wasm-bindgen" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342" +checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -7479,24 +7629,24 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd" +checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da" dependencies = [ "bumpalo", "log", "once_cell", "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-futures" -version = "0.4.37" +version = "0.4.42" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03" +checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0" dependencies = [ "cfg-if", "js-sys", @@ -7506,9 +7656,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d" +checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -7516,28 +7666,28 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" +checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.87" +version = "0.2.92" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1" +checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96" [[package]] name = "web-sys" -version = "0.3.64" +version = "0.3.69" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b" +checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef" dependencies = [ "js-sys", "wasm-bindgen", @@ -7549,7 +7699,7 @@ version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53" dependencies = [ - "ring 0.17.2", + "ring 0.17.8", "untrusted 0.9.0", ] @@ -7573,9 +7723,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.25.2" +version = "0.25.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" +checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" [[package]] name = "wg" @@ -7590,11 +7740,12 @@ dependencies = [ [[package]] name = "whoami" -version = "1.4.1" +version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22fc3756b8a9133049b26c7f61ab35416c130e8c09b660f5b3958b446f52cc50" +checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9" dependencies = [ - "wasm-bindgen", + "redox_syscall 0.4.1", + "wasite", "web-sys", ] @@ -7630,21 +7781,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] -name = "windows" -version = "0.48.0" +name = "windows-core" +version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", + "windows-targets 0.52.4", ] [[package]] @@ -7657,18 +7799,12 @@ dependencies = [ ] [[package]] -name = "windows-targets" -version = "0.42.2" +name = "windows-sys" +version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", + "windows-targets 0.52.4", ] [[package]] @@ -7687,10 +7823,19 @@ dependencies = [ ] [[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" +name = "windows-targets" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" +checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b" +dependencies = [ + "windows_aarch64_gnullvm 0.52.4", + "windows_aarch64_msvc 0.52.4", + "windows_i686_gnu 0.52.4", + "windows_i686_msvc 0.52.4", + "windows_x86_64_gnu 0.52.4", + "windows_x86_64_gnullvm 0.52.4", + "windows_x86_64_msvc 0.52.4", +] [[package]] name = "windows_aarch64_gnullvm" @@ -7699,10 +7844,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" [[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" +name = "windows_aarch64_gnullvm" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" +checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9" [[package]] name = "windows_aarch64_msvc" @@ -7711,10 +7856,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" [[package]] -name = "windows_i686_gnu" -version = "0.42.2" +name = "windows_aarch64_msvc" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" +checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675" [[package]] name = "windows_i686_gnu" @@ -7723,10 +7868,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" [[package]] -name = "windows_i686_msvc" -version = "0.42.2" +name = "windows_i686_gnu" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" +checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3" [[package]] name = "windows_i686_msvc" @@ -7735,10 +7880,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" [[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" +name = "windows_i686_msvc" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" +checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02" [[package]] name = "windows_x86_64_gnu" @@ -7747,10 +7892,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" [[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" +name = "windows_x86_64_gnu" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" +checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03" [[package]] name = "windows_x86_64_gnullvm" @@ -7759,10 +7904,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" [[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" +name = "windows_x86_64_gnullvm" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" +checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177" [[package]] name = "windows_x86_64_msvc" @@ -7770,11 +7915,26 @@ version = "0.48.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8" + +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] + [[package]] name = "winnow" -version = "0.5.16" +version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711d82167854aff2018dfd193aa0fef5370f456732f0d5a0c59b0f1b4b907" +checksum = "dffa400e67ed5a4dd237983829e66475f0a4a26938c4b04c21baede6262215b8" dependencies = [ "memchr", ] @@ -7813,29 +7973,20 @@ dependencies = [ "oid-registry", "rusticata-macros", "thiserror", - "time 0.3.29", + "time 0.3.35", ] [[package]] name = "xxhash-rust" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9828b178da53440fa9c766a3d2f73f7cf5d0ac1fe3980c1e5018d899fd19e07b" - -[[package]] -name = "yaml-rust" -version = "0.4.5" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85" -dependencies = [ - "linked-hash-map", -] +checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03" [[package]] name = "yansi" -version = "1.0.0-rc.1" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1367295b8f788d371ce2dbc842c7b709c73ee1364d30351dd300ec2203b12377" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" [[package]] name = "yasna" @@ -7843,7 +7994,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd" dependencies = [ - "time 0.3.29", + "time 0.3.35", ] [[package]] @@ -7863,7 +8014,7 @@ checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -7883,7 +8034,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.38", + "syn 2.0.58", ] [[package]] @@ -7907,11 +8058,10 @@ dependencies = [ [[package]] name = "zstd-sys" -version = "2.0.8+zstd.1.5.5" +version = "2.0.10+zstd.1.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5556e6ee25d32df2586c098bbfa278803692a20d0ab9565e049480d52707ec8c" +checksum = "c253a4914af5bafc8fa8c86ee400827e83cf6ec01195ec1f1ed8441bf00d65aa" dependencies = [ "cc", - "libc", "pkg-config", ] diff --git a/nft_ingester/Cargo.toml b/nft_ingester/Cargo.toml index 1eb403ca0..fd17a2bed 100644 --- a/nft_ingester/Cargo.toml +++ b/nft_ingester/Cargo.toml @@ -6,8 +6,8 @@ repository = { workspace = true } publish = { workspace = true } [dependencies] - async-trait = { workspace = true } +blockbuster = { workspace = true } borsh = { workspace = true } bs58 = { workspace = true } cadence = { workspace = true } diff --git a/nft_ingester/src/backfiller.rs b/nft_ingester/src/backfiller.rs index 7d7b32060..fd7d3e19c 100644 --- a/nft_ingester/src/backfiller.rs +++ b/nft_ingester/src/backfiller.rs @@ -628,9 +628,14 @@ impl<'a, T: Messenger> Backfiller<'a, T> { &mut self, btree: &BackfillTree, ) -> Result, IngesterError> { - let address = Pubkey::try_from(btree.unique_tree.tree.as_slice()).map_err(|error| { - IngesterError::DeserializationError(format!("failed to parse pubkey: {error:?}")) - })?; + let address = match Pubkey::try_from(btree.unique_tree.tree.as_slice()) { + Ok(pubkey) => pubkey, + Err(error) => { + return Err(IngesterError::DeserializationError(format!( + "failed to parse pubkey: {error:?}" + ))) + } + }; let slots = self.find_slots_via_address(&address).await?; let address = btree.unique_tree.tree.clone(); @@ -961,7 +966,7 @@ impl<'a, T: Messenger> Backfiller<'a, T> { // Filter out transactions that don't have to do with the tree we are interested in or // the Bubblegum program. let tb = tree.to_bytes(); - let bubblegum = mpl_bubblegum::ID.to_bytes(); + let bubblegum = blockbuster::programs::bubblegum::ID.to_bytes(); if account_keys.iter().all(|pk| *pk != tb && *pk != bubblegum) { continue; } diff --git a/nft_ingester/src/error/mod.rs b/nft_ingester/src/error/mod.rs index ddeae0ba6..37ed5f24b 100644 --- a/nft_ingester/src/error/mod.rs +++ b/nft_ingester/src/error/mod.rs @@ -1,15 +1,27 @@ -use { - crate::tasks::TaskData, plerkle_messenger::MessengerError, - plerkle_serialization::error::PlerkleSerializationError, sea_orm::DbErr, - tokio::sync::mpsc::error::SendError, -}; +use crate::tasks::TaskData; +use blockbuster::error::BlockbusterError; +use plerkle_messenger::MessengerError; +use plerkle_serialization::error::PlerkleSerializationError; +use sea_orm::{DbErr, TransactionError}; +use thiserror::Error; +use tokio::sync::mpsc::error::SendError; -#[derive(Debug, thiserror::Error)] +#[derive(Error, Debug, PartialEq, Eq)] pub enum IngesterError { + #[error("ChangeLog Event Malformed")] + ChangeLogEventMalformed, + #[error("Compressed Asset Event Malformed")] + CompressedAssetEventMalformed, #[error("Network Error: {0}")] BatchInitNetworkingError(String), + #[error("Error writing batch files")] + BatchInitIOError, + #[error("Storage listener error: ({msg})")] + StorageListenerError { msg: String }, #[error("Storage Write Error: {0}")] StorageWriteError(String), + #[error("NotImplemented")] + NotImplemented, #[error("Deserialization Error: {0}")] DeserializationError(String), #[error("Task Manager Error: {0}")] @@ -24,6 +36,12 @@ pub enum IngesterError { SerializatonError(String), #[error("Messenger error; {0}")] MessengerError(String), + #[error("Blockbuster Parsing error: {0}")] + ParsingError(String), + #[error("Database Error: {0}")] + DatabaseError(String), + #[error("Unknown Task Type: {0}")] + UnknownTaskType(String), #[error("BG Task Manager Not Started")] TaskManagerNotStarted, #[error("Unrecoverable task error: {0}")] @@ -32,6 +50,8 @@ pub enum IngesterError { CacheStorageWriteError(String), #[error("HttpError {status_code}")] HttpError { status_code: String }, + #[error("AssetIndex Error {0}")] + AssetIndexError(String), } impl From for IngesterError { @@ -52,12 +72,30 @@ impl From for IngesterError { } } +impl From for IngesterError { + fn from(err: BlockbusterError) -> Self { + IngesterError::ParsingError(err.to_string()) + } +} + +impl From for IngesterError { + fn from(_err: std::io::Error) -> Self { + IngesterError::BatchInitIOError + } +} + impl From for IngesterError { fn from(e: DbErr) -> Self { IngesterError::StorageWriteError(e.to_string()) } } +impl From> for IngesterError { + fn from(e: TransactionError) -> Self { + IngesterError::StorageWriteError(e.to_string()) + } +} + impl From> for IngesterError { fn from(err: SendError) -> Self { IngesterError::TaskManagerError(format!("Could not create task: {:?}", err.to_string())) From 096616d3355405b922198e6aa624fb842f4ed226 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Thu, 23 Nov 2023 22:11:52 -0500 Subject: [PATCH 12/21] remove plerkle from program_transformers --- nft_ingester/src/transaction_notifications.rs | 2 +- program_transformers/Cargo.toml | 5 ++++- program_transformers/src/bubblegum/decompress.rs | 16 ++++------------ 3 files changed, 9 insertions(+), 14 deletions(-) diff --git a/nft_ingester/src/transaction_notifications.rs b/nft_ingester/src/transaction_notifications.rs index df005bc56..5335de6dc 100644 --- a/nft_ingester/src/transaction_notifications.rs +++ b/nft_ingester/src/transaction_notifications.rs @@ -10,7 +10,7 @@ use { log::{debug, error}, plerkle_messenger::{ConsumptionType, Messenger, MessengerConfig, RecvData}, plerkle_serialization::root_as_transaction_info, - program_transformers::ProgramTransformer, + program_transformers::{error::ProgramTransformerResult, ProgramTransformer, TransactionInfo}, sqlx::{Pool, Postgres}, std::sync::Arc, tokio::{ diff --git a/program_transformers/Cargo.toml b/program_transformers/Cargo.toml index 35bab7a19..08f784632 100644 --- a/program_transformers/Cargo.toml +++ b/program_transformers/Cargo.toml @@ -10,7 +10,10 @@ blockbuster = { workspace = true } bs58 = { workspace = true } cadence = { workspace = true } cadence-macros = { workspace = true } -digital_asset_types = { workspace = true, features = ["json_types", "sql_types"] } +digital_asset_types = { workspace = true, features = [ + "json_types", + "sql_types", +] } futures = { workspace = true } heck = { workspace = true } mpl-bubblegum = { workspace = true } diff --git a/program_transformers/src/bubblegum/decompress.rs b/program_transformers/src/bubblegum/decompress.rs index 9db67e8b8..208e9aabc 100644 --- a/program_transformers/src/bubblegum/decompress.rs +++ b/program_transformers/src/bubblegum/decompress.rs @@ -17,18 +17,10 @@ pub async fn decompress<'c, T>( where T: ConnectionTrait + TransactionTrait, { - let id_bytes = bundle.keys.get(3).unwrap().0.as_slice(); + let id_bytes = bundle.keys.get(3).unwrap().to_bytes().to_vec(); // Partial update of asset table with just leaf. - upsert_asset_with_leaf_info_for_decompression(txn, id_bytes.to_vec()).await?; - upsert_asset_with_compression_info( - txn, - id_bytes.to_vec(), - false, - false, - 1, - Some(id_bytes.to_vec()), - true, - ) - .await + upsert_asset_with_leaf_info_for_decompression(txn, id_bytes.clone()).await?; + upsert_asset_with_compression_info(txn, id_bytes.clone(), false, false, 1, Some(id_bytes), true) + .await } From ef0b0e9c10b6372dc810286b9b4277233f65916b Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Sun, 26 Nov 2023 19:14:56 -0500 Subject: [PATCH 13/21] nft_ingester2: grpc2redis --- Cargo.lock | 765 +++++++++++++++++++++++++--- Cargo.toml | 20 +- nft_ingester2/Cargo.toml | 45 ++ nft_ingester2/build.rs | 38 ++ nft_ingester2/config-grpc2redis.yml | 24 + nft_ingester2/src/config.rs | 153 ++++++ nft_ingester2/src/grpc.rs | 147 ++++++ nft_ingester2/src/ingester.rs | 5 + nft_ingester2/src/main.rs | 75 +++ nft_ingester2/src/prom.rs | 106 ++++ nft_ingester2/src/redis.rs | 25 + nft_ingester2/src/tracing.rs | 32 ++ nft_ingester2/src/util.rs | 16 + nft_ingester2/src/version.rs | 22 + 14 files changed, 1408 insertions(+), 65 deletions(-) create mode 100644 nft_ingester2/Cargo.toml create mode 100644 nft_ingester2/build.rs create mode 100644 nft_ingester2/config-grpc2redis.yml create mode 100644 nft_ingester2/src/config.rs create mode 100644 nft_ingester2/src/grpc.rs create mode 100644 nft_ingester2/src/ingester.rs create mode 100644 nft_ingester2/src/main.rs create mode 100644 nft_ingester2/src/prom.rs create mode 100644 nft_ingester2/src/redis.rs create mode 100644 nft_ingester2/src/tracing.rs create mode 100644 nft_ingester2/src/util.rs create mode 100644 nft_ingester2/src/version.rs diff --git a/Cargo.lock b/Cargo.lock index 730f88db4..debbc5287 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -841,6 +841,60 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80" +[[package]] +name = "autotools" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef941527c41b0fc0dd48511a8154cd5fc7e29200a0ff8b7203c5d777dbc795cf" +dependencies = [ + "cc", +] + +[[package]] +name = "axum" +version = "0.6.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b829e4e32b91e643de6eafe82b1d90675f5874230191a4ffbc1b336dec4d6bf" +dependencies = [ + "async-trait", + "axum-core", + "bitflags 1.3.2", + "bytes", + "futures-util", + "http", + "http-body", + "hyper", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "sync_wrapper", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "axum-core" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "759fa577a247914fd3f7f76d62972792636412fbfd634cd452f6a385a74d2d2c" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http", + "http-body", + "mime", + "rustversion", + "tower-layer", + "tower-service", +] + [[package]] name = "backon" version = "0.4.4" @@ -1328,6 +1382,18 @@ dependencies = [ "thiserror", ] +[[package]] +name = "cargo-lock" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e11c675378efb449ed3ce8de78d75d0d80542fc98487c26aba28eb3b82feac72" +dependencies = [ + "semver", + "serde", + "toml 0.7.8", + "url", +] + [[package]] name = "cc" version = "1.0.92" @@ -2274,6 +2340,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fcfdc7a0362c9f4444381a9e697c79d435fe65b52a37466fc2c1184cee9edc6" +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + [[package]] name = "flatbuffers" version = "23.5.26" @@ -2538,6 +2610,32 @@ version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" +[[package]] +name = "git-version" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19" +dependencies = [ + "git-version-macro", +] + +[[package]] +name = "git-version-macro" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "glob" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" + [[package]] name = "globset" version = "0.4.14" @@ -2822,6 +2920,18 @@ dependencies = [ "tokio-rustls 0.24.1", ] +[[package]] +name = "hyper-timeout" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1" +dependencies = [ + "hyper", + "pin-project-lite", + "tokio", + "tokio-io-timeout", +] + [[package]] name = "hyper-tls" version = "0.5.0" @@ -2953,6 +3063,12 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "integer-encoding" +version = "3.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02" + [[package]] name = "integration_tests" version = "0.1.0" @@ -3057,6 +3173,17 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "json5" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1" +dependencies = [ + "pest", + "pest_derive", + "serde", +] + [[package]] name = "jsonpath_lib" version = "0.3.0" @@ -3341,6 +3468,12 @@ dependencies = [ "regex-automata 0.1.10", ] +[[package]] +name = "matchit" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" + [[package]] name = "md-5" version = "0.10.6" @@ -3525,6 +3658,12 @@ dependencies = [ "thiserror", ] +[[package]] +name = "multimap" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03" + [[package]] name = "native-tls" version = "0.2.11" @@ -3583,6 +3722,37 @@ dependencies = [ "url", ] +[[package]] +name = "nft_ingester2" +version = "0.7.2" +dependencies = [ + "anyhow", + "atty", + "cargo-lock", + "clap 4.5.4", + "futures", + "git-version", + "hyper", + "json5", + "lazy_static", + "opentelemetry", + "opentelemetry-jaeger", + "opentelemetry_sdk", + "prometheus", + "redis 0.25.3", + "serde", + "serde_yaml", + "solana-sdk", + "tokio", + "tracing", + "tracing-opentelemetry", + "tracing-subscriber", + "vergen", + "yellowstone-grpc-client", + "yellowstone-grpc-proto", + "yellowstone-grpc-tools", +] + [[package]] name = "nix" version = "0.26.4" @@ -3783,6 +3953,15 @@ dependencies = [ "syn 2.0.58", ] +[[package]] +name = "num_threads" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9" +dependencies = [ + "libc", +] + [[package]] name = "number_prefix" version = "0.4.0" @@ -3887,6 +4066,87 @@ dependencies = [ "vcpkg", ] +[[package]] +name = "opentelemetry" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e32339a5dc40459130b3bd269e9892439f55b33e772d2a9d402a789baaf4e8a" +dependencies = [ + "futures-core", + "futures-sink", + "indexmap 2.2.6", + "js-sys", + "once_cell", + "pin-project-lite", + "thiserror", + "urlencoding", +] + +[[package]] +name = "opentelemetry-jaeger" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e617c66fd588e40e0dbbd66932fdc87393095b125d4459b1a3a10feb1712f8a1" +dependencies = [ + "async-trait", + "futures-core", + "futures-util", + "opentelemetry", + "opentelemetry-semantic-conventions", + "opentelemetry_sdk", + "thrift", + "tokio", +] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5774f1ef1f982ef2a447f6ee04ec383981a3ab99c8e77a1a7b30182e65bbc84" +dependencies = [ + "opentelemetry", +] + +[[package]] +name = "opentelemetry_sdk" +version = "0.21.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f16aec8a98a457a52664d69e0091bac3a0abd18ead9b641cb00202ba4e0efe4" +dependencies = [ + "async-trait", + "crossbeam-channel", + "futures-channel", + "futures-executor", + "futures-util", + "glob", + "once_cell", + "opentelemetry", + "ordered-float 4.2.0", + "percent-encoding", + "rand 0.8.5", + "thiserror", + "tokio", + "tokio-stream", +] + +[[package]] +name = "ordered-float" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "ordered-float" +version = "4.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a76df7075c7d4d01fdcb46c912dd17fba5b60c78ea480b475f2b6ab6f666584e" +dependencies = [ + "num-traits", +] + [[package]] name = "os_str_bytes" version = "6.6.1" @@ -4047,6 +4307,61 @@ dependencies = [ "num", ] +[[package]] +name = "pest" +version = "2.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "311fb059dee1a7b802f036316d790138c613a4e8b180c822e3925a662e9f0c95" +dependencies = [ + "memchr", + "thiserror", + "ucd-trie", +] + +[[package]] +name = "pest_derive" +version = "2.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f73541b156d32197eecda1a4014d7f868fd2bcb3c550d5386087cfba442bf69c" +dependencies = [ + "pest", + "pest_generator", +] + +[[package]] +name = "pest_generator" +version = "2.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c35eeed0a3fab112f75165fdc026b3913f4183133f19b49be773ac9ea966e8bd" +dependencies = [ + "pest", + "pest_meta", + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "pest_meta" +version = "2.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2adbf29bb9776f28caece835398781ab24435585fe0d4dc1374a61db5accedca" +dependencies = [ + "once_cell", + "pest", + "sha2 0.10.8", +] + +[[package]] +name = "petgraph" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9" +dependencies = [ + "fixedbitset", + "indexmap 2.2.6", +] + [[package]] name = "pin-project" version = "1.1.5" @@ -4127,7 +4442,7 @@ dependencies = [ "figment", "futures", "log", - "redis", + "redis 0.22.3", "serde", "thiserror", ] @@ -4217,6 +4532,16 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" +[[package]] +name = "prettyplease" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d3928fb5db768cb86f891ff014f0144589297e3c6a1aba6ed7cecfdace270c7" +dependencies = [ + "proc-macro2", + "syn 2.0.58", +] + [[package]] name = "proc-macro-crate" version = "0.1.5" @@ -4331,12 +4656,74 @@ dependencies = [ "thiserror", ] +[[package]] +name = "prost" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0f5d036824e4761737860779c906171497f6d55681139d8312388f8fe398922" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-build" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80b776a1b2dc779f5ee0641f8ade0125bc1298dd41a9a0c16d8bd57b42d222b1" +dependencies = [ + "bytes", + "heck 0.5.0", + "itertools 0.12.1", + "log", + "multimap", + "once_cell", + "petgraph", + "prettyplease", + "prost", + "prost-types", + "regex", + "syn 2.0.58", + "tempfile", +] + +[[package]] +name = "prost-derive" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19de2de2a00075bf566bee3bd4db014b11587e84184d3f7a791bc17f1a8e9e48" +dependencies = [ + "anyhow", + "itertools 0.12.1", + "proc-macro2", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "prost-types" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3235c33eb02c1f1e212abdbe34c78b264b038fb58ca612664343271e36e55ffe" +dependencies = [ + "prost", +] + [[package]] name = "protobuf" version = "2.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94" +[[package]] +name = "protobuf-src" +version = "1.1.0+21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7ac8852baeb3cc6fb83b93646fb93c0ffe5d14bf138c945ceb4b9948ee0e3c1" +dependencies = [ + "autotools", +] + [[package]] name = "proxy-wasm" version = "0.2.1" @@ -4633,6 +5020,29 @@ dependencies = [ "url", ] +[[package]] +name = "redis" +version = "0.25.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6472825949c09872e8f2c50bde59fcefc17748b6be5c90fd67cd8b4daca73bfd" +dependencies = [ + "async-trait", + "bytes", + "combine 4.6.7", + "futures-util", + "itoa", + "native-tls", + "percent-encoding", + "pin-project-lite", + "ryu", + "sha1_smol", + "socket2 0.5.6", + "tokio", + "tokio-native-tls", + "tokio-util", + "url", +] + [[package]] name = "redox_syscall" version = "0.2.16" @@ -5285,6 +5695,9 @@ name = "semver" version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca" +dependencies = [ + "serde", +] [[package]] name = "serde" @@ -5630,9 +6043,9 @@ dependencies = [ [[package]] name = "solana-account-decoder" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d145d4e1e33bfecd209059a0c4c75d623dbcaeb565b4c197f1815257be45726a" +checksum = "8d76c43ef61f527d719b5c6bfa5a62ebba60839739125da9e8a00fb82349afd2" dependencies = [ "Inflector", "base64 0.21.7", @@ -5655,9 +6068,9 @@ dependencies = [ [[package]] name = "solana-clap-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1deaf83f98be3ba9ecee057efa5cdfa6112267e5b1ff53c4ef4b727f66090b9a" +checksum = "eb19b9bbd92eee2d8f637026559a9fb48bd98aba534caedf070498a50c91fce8" dependencies = [ "chrono", "clap 2.34.0", @@ -5672,9 +6085,9 @@ dependencies = [ [[package]] name = "solana-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a8912026a203ff0d90973e7363f141c6ce569484e06ee0a6f72992144263136" +checksum = "9538e3db584a8b1e70060f1f24222b8e0429f18b607f531fb45eb826f4917265" dependencies = [ "async-trait", "bincode", @@ -5705,9 +6118,9 @@ dependencies = [ [[package]] name = "solana-config-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4000f4717f86c5f9e1105378e3a6521db770d0ad68417f59960ca4b51103fcd0" +checksum = "e3afd4e309d304e296765cab716fb1fd66c66ec300465c8b26f8cce763275132" dependencies = [ "bincode", "chrono", @@ -5719,9 +6132,9 @@ dependencies = [ [[package]] name = "solana-connection-cache" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8b1a4d67c01e5c4464ed9bffb656dec2c88e9bfd7d45bf754f650150e5d81db" +checksum = "92716758e8c0e1c0bc2a5ac2eb3df443a0337fd3991cd38a3b02b12c3fbd18ce" dependencies = [ "async-trait", "bincode", @@ -5741,9 +6154,9 @@ dependencies = [ [[package]] name = "solana-frozen-abi" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1790013c7969353000c22907fc21610adb3389a7c9a27a386ebe7fb32b2ad307" +checksum = "fb1b8230474ae9f7c841060c299999124582e8d2a0448d7847720792e98cc64e" dependencies = [ "ahash 0.8.5", "blake3", @@ -5771,9 +6184,9 @@ dependencies = [ [[package]] name = "solana-frozen-abi-macro" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3ed2b49a3dd03ddd5107d6e629e8e5895724227a057b3511bf0c107c6d48308" +checksum = "793910ab733b113b80c357f8f492dda2fabd5671c4ea03db3aa4e46b938fdbe3" dependencies = [ "proc-macro2", "quote", @@ -5783,9 +6196,9 @@ dependencies = [ [[package]] name = "solana-logger" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfc0d5b4f046d07e845b69178989a6b3bf168a82eeee006adb77391b339bce64" +checksum = "6d3f819af39632dc538a566c937253bf46256e4c0e60f621c6db448bc7c76294" dependencies = [ "env_logger 0.9.3", "lazy_static", @@ -5794,9 +6207,9 @@ dependencies = [ [[package]] name = "solana-measure" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "857178177c6b378bcfc35df6867a6eef211059f5e4ab01ee87355d6b7493b556" +checksum = "cb045f0235b16f7d926f6e0338db822747d61559a1368c3cb017ba6e02c516d0" dependencies = [ "log", "solana-sdk", @@ -5804,9 +6217,9 @@ dependencies = [ [[package]] name = "solana-metrics" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c68f5cbfbafd002b4d94728748f632a3bd27772ca5c7139710d65940c95477c" +checksum = "1af84362ad5804dc64ca88b1ca5c35bd41321e12d42c798ac06a6fbb60dd0e70" dependencies = [ "crossbeam-channel", "gethostname", @@ -5819,9 +6232,9 @@ dependencies = [ [[package]] name = "solana-net-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ce93c50199f077df9d8fd4a82bbdfe654422e1d21e5eecb7f878c4e0078f92f" +checksum = "f8e640a95d317cad1322015c5a2b6a71697fd8dabebcb8dd33ed7f5a22869d12" dependencies = [ "bincode", "clap 3.2.25", @@ -5841,9 +6254,9 @@ dependencies = [ [[package]] name = "solana-perf" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a233bc2032f4b3f462fe13325cd1a336f355e1d9e793faada488db409cec0d6" +checksum = "4266c4bd46620a925b8d508c26578d5559e97fcff6735fd22e39f369c3996ee1" dependencies = [ "ahash 0.8.5", "bincode", @@ -5870,9 +6283,9 @@ dependencies = [ [[package]] name = "solana-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b2ae4ec9dd6fc76202c94d23942da3cf624325a178e1b0125e70db90b8d7f15" +checksum = "581f38a870bffbe623d900c68579984671f8dfa35bbfb3309d7134de22ce8652" dependencies = [ "ark-bn254", "ark-ec", @@ -5924,9 +6337,9 @@ dependencies = [ [[package]] name = "solana-program-runtime" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b50a6da7b501117f68ef51fc113d771b52af646dc42c43af23a85e32461d59c9" +checksum = "490b6f65aced077e0c5e57c20f151a134458fc350905c20d7dcf3f2162eaa6f6" dependencies = [ "base64 0.21.7", "bincode", @@ -5952,9 +6365,9 @@ dependencies = [ [[package]] name = "solana-pubsub-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf920143eb7d5bd5f2ea8fc6ab8a1f521512dfe50af7833af40d7cbae83d955d" +checksum = "c0dc2b26a7a9860f180ce11f69b0ff2a8bea0d4b9e97daee741b1e76565b3c82" dependencies = [ "crossbeam-channel", "futures-util", @@ -5977,9 +6390,9 @@ dependencies = [ [[package]] name = "solana-quic-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "627491c0afd615efb2538c8a49948663ac01aadf99a3cfebb0a63e2b9431ed79" +checksum = "727474945d51be37ffe03e7b1d6c9630da41228c7b298a8f45098c203a78ac89" dependencies = [ "async-mutex", "async-trait", @@ -6004,9 +6417,9 @@ dependencies = [ [[package]] name = "solana-rayon-threadlimit" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d5c306f32e26031c043c218a0ba3cde08cbb0e08511ab8a4128445d92a535e0" +checksum = "853794cccf3bd1984419a594040dfed19666e5a9ad33b0906d4174bc394b22af" dependencies = [ "lazy_static", "num_cpus", @@ -6014,9 +6427,9 @@ dependencies = [ [[package]] name = "solana-remote-wallet" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1c9dbb8cca1b917a01979a1ca98b682f6123df56f11a5227a37c36494ad7740" +checksum = "b368f270526a5f92ec47c45a6b74ac304b62b08c169b45cf91e0d2f1703889bd" dependencies = [ "console", "dialoguer", @@ -6033,9 +6446,9 @@ dependencies = [ [[package]] name = "solana-rpc-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2edc8c0f26561e770f28edb9d456221a5554ee90eeb9052ed38942dbb31c035b" +checksum = "71b766876b0c56950ab530d8495ef7eeaeb79e162f03dadaffc0d6852de9e844" dependencies = [ "async-trait", "base64 0.21.7", @@ -6059,9 +6472,9 @@ dependencies = [ [[package]] name = "solana-rpc-client-api" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ff63ab63805a6302ec21284a1138daf5478020f79641d77e53bb84f16c1f5a6" +checksum = "876b2e410cc2403ea3216893f05034b02a180431100eb831d0b67b14fca4d29f" dependencies = [ "base64 0.21.7", "bs58 0.4.0", @@ -6081,9 +6494,9 @@ dependencies = [ [[package]] name = "solana-rpc-client-nonce-utils" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "897db0c1085b8a99ca35871132b6dc6dca3eff68d9210fcd168ccc2e3843dc26" +checksum = "ebdb3f02fb3cce3c967f718bc77b79433c24aa801b63dc70f374e8759b2424e4" dependencies = [ "clap 2.34.0", "solana-clap-utils", @@ -6094,9 +6507,9 @@ dependencies = [ [[package]] name = "solana-sdk" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "368430d6c9f033e86f8f590d19232d10986d1188c3ad3a6836628d2acc09c21a" +checksum = "0d70ab837cc79ed67df6fdb145f1ffd544f1eaa60b0757b750f4864b90498bad" dependencies = [ "assert_matches", "base64 0.21.7", @@ -6148,9 +6561,9 @@ dependencies = [ [[package]] name = "solana-sdk-macro" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f554d2a144bb0138cfdeced9961cc8a09aaa09f0c3c9a63bd10da41c4a06d420" +checksum = "5f9d0433c4084a3260a32ec67f6b4272c4232d15e732be542cd5dfdf0ae1e784" dependencies = [ "bs58 0.4.0", "proc-macro2", @@ -6167,9 +6580,9 @@ checksum = "468aa43b7edb1f9b7b7b686d5c3aeb6630dc1708e86e31343499dd5c4d775183" [[package]] name = "solana-streamer" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e28e8941bc0b137f851626ff4d4ce9ebcf9be10619b48d2ed83cd1953af21821" +checksum = "d70eda40efb5bc57ad50b1ac8452485065c1adae0e701a0348b397db054e2ab5" dependencies = [ "async-channel 1.9.0", "bytes", @@ -6199,9 +6612,9 @@ dependencies = [ [[package]] name = "solana-thin-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "760b94e2875b54350f786c85faf50fa1a9a37ae46e9897215d19b373fc2f58cd" +checksum = "ca3c510144695c3d1ee1f84dd9975af7f7d35c168447c484bbd35c21e903c515" dependencies = [ "bincode", "log", @@ -6214,9 +6627,9 @@ dependencies = [ [[package]] name = "solana-tpu-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cfdc7ff6cdc1512661de1f9f40723f88dc1e94c8b8938bd537f3713239173e2" +checksum = "44f27c8fec609179a7dfc287060df2a926c8cd89329235c4b8d78bd019a72462" dependencies = [ "async-trait", "bincode", @@ -6238,9 +6651,9 @@ dependencies = [ [[package]] name = "solana-transaction-status" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba7131d11c8d5a068bfc26a9dc8c9ee0d77eaf60856dd0c8be880542fc5fbbd6" +checksum = "29f58f2f864d900eddf2e21a99ebe445b6be525d597e44952f075d8237035b8e" dependencies = [ "Inflector", "base64 0.21.7", @@ -6263,9 +6676,9 @@ dependencies = [ [[package]] name = "solana-udp-client" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54647340d7fa1708c217cbc2411259c5b3784c2df55c1eb4353aca296635ed87" +checksum = "27ead118c5d549e4345dc59cbc5d9b282164f3e5334707f186e3aa10d40e3b30" dependencies = [ "async-trait", "solana-connection-cache", @@ -6278,9 +6691,9 @@ dependencies = [ [[package]] name = "solana-version" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1de7a6bad7dff1c595be2eec0c3800a482c6068f3c87c6df87ed091b4e6e642e" +checksum = "532f5d631562587facc5fe88abd2e31c0d1f29012b6766c664db9f05a39fb05b" dependencies = [ "log", "rustc_version", @@ -6294,9 +6707,9 @@ dependencies = [ [[package]] name = "solana-vote-program" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c828d118d1f135baacfbf51412c4f1ac18af19fdbee43b002d2908e69cdf50b" +checksum = "c684430058b0a2e733936a8851c8843a3a6316ccd5c969d39411a479d6489642" dependencies = [ "bincode", "log", @@ -6316,9 +6729,9 @@ dependencies = [ [[package]] name = "solana-zk-token-sdk" -version = "1.17.30" +version = "1.17.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "112944743b08f7e1101368ff6d84745e7b4abb075fabaccc02e01bd3ce4b6d6c" +checksum = "5aef1b48d9fdb2619349d2d15942d83c99aabe995ff945d9b418176373aa823c" dependencies = [ "aes-gcm-siv", "base64 0.21.7", @@ -6942,6 +7355,28 @@ dependencies = [ "once_cell", ] +[[package]] +name = "threadpool" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa" +dependencies = [ + "num_cpus", +] + +[[package]] +name = "thrift" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e54bc85fc7faa8bc175c4bab5b92ba8d9a3ce893d0e9f42cc455c8ab16a9e09" +dependencies = [ + "byteorder", + "integer-encoding", + "log", + "ordered-float 2.10.1", + "threadpool", +] + [[package]] name = "time" version = "0.1.45" @@ -6961,7 +7396,9 @@ checksum = "ef89ece63debf11bc32d1ed8d078ac870cbeb44da02afb02a9ff135ae7ca0582" dependencies = [ "deranged", "itoa", + "libc", "num-conv", + "num_threads", "powerfmt", "serde", "time-core", @@ -7038,6 +7475,16 @@ dependencies = [ "windows-sys 0.48.0", ] +[[package]] +name = "tokio-io-timeout" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30b74022ada614a1b4834de765f9bb43877f910cc8ce4be40e89042c9223a8bf" +dependencies = [ + "pin-project-lite", + "tokio", +] + [[package]] name = "tokio-macros" version = "2.2.0" @@ -7130,6 +7577,18 @@ dependencies = [ "serde", ] +[[package]] +name = "toml" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257" +dependencies = [ + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit 0.19.15", +] + [[package]] name = "toml" version = "0.8.12" @@ -7158,6 +7617,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" dependencies = [ "indexmap 2.2.6", + "serde", + "serde_spanned", "toml_datetime", "winnow 0.5.40", ] @@ -7186,12 +7647,79 @@ dependencies = [ "winnow 0.6.5", ] +[[package]] +name = "tonic" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d560933a0de61cf715926b9cac824d4c883c2c43142f787595e48280c40a1d0e" +dependencies = [ + "async-stream", + "async-trait", + "axum", + "base64 0.21.7", + "bytes", + "flate2", + "h2", + "http", + "http-body", + "hyper", + "hyper-timeout", + "percent-encoding", + "pin-project", + "prost", + "rustls 0.21.10", + "rustls-native-certs", + "rustls-pemfile", + "tokio", + "tokio-rustls 0.24.1", + "tokio-stream", + "tower", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tonic-build" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d021fc044c18582b9a2408cd0dd05b1596e3ecdb5c4df822bb0183545683889" +dependencies = [ + "prettyplease", + "proc-macro2", + "prost-build", + "quote", + "syn 2.0.58", +] + +[[package]] +name = "tonic-health" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f80db390246dfb46553481f6024f0082ba00178ea495dbb99e70ba9a4fafb5e1" +dependencies = [ + "async-stream", + "prost", + "tokio", + "tokio-stream", + "tonic", +] + [[package]] name = "tower" version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" dependencies = [ + "futures-core", + "futures-util", + "indexmap 1.9.3", + "pin-project", + "pin-project-lite", + "rand 0.8.5", + "slab", + "tokio", + "tokio-util", "tower-layer", "tower-service", "tracing", @@ -7271,6 +7799,24 @@ dependencies = [ "tracing-core", ] +[[package]] +name = "tracing-opentelemetry" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c67ac25c5407e7b961fafc6f7e9aa5958fd297aada2d20fa2ae1737357e55596" +dependencies = [ + "js-sys", + "once_cell", + "opentelemetry", + "opentelemetry_sdk", + "smallvec", + "tracing", + "tracing-core", + "tracing-log", + "tracing-subscriber", + "web-time", +] + [[package]] name = "tracing-serde" version = "0.1.3" @@ -7399,6 +7945,12 @@ version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" +[[package]] +name = "ucd-trie" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9" + [[package]] name = "uncased" version = "0.9.10" @@ -7520,6 +8072,12 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "urlencoding" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" + [[package]] name = "utf-8" version = "0.7.6" @@ -7566,6 +8124,18 @@ version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" +[[package]] +name = "vergen" +version = "8.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e27d6bdd219887a9eadd19e1c34f32e47fa332301184935c6d9bca26f3cca525" +dependencies = [ + "anyhow", + "rustc_version", + "rustversion", + "time 0.3.35", +] + [[package]] name = "version_check" version = "0.9.4" @@ -7693,6 +8263,16 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "web-time" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa30049b1c872b72c89866d458eae9f20380ab280ffd1b1e18df2d3e2d98cfe0" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "webpki" version = "0.22.4" @@ -7997,6 +8577,65 @@ dependencies = [ "time 0.3.35", ] +[[package]] +name = "yellowstone-grpc-client" +version = "1.15.0+solana.1.17.28" +source = "git+https://github.com/rpcpool/yellowstone-grpc.git?tag=v1.14.1+solana.1.17.28#8fb667501cdcee0f50d8edbf5c382c97f6b4bf07" +dependencies = [ + "bytes", + "futures", + "thiserror", + "tonic", + "tonic-health", + "yellowstone-grpc-proto", +] + +[[package]] +name = "yellowstone-grpc-proto" +version = "1.14.0+solana.1.17.28" +source = "git+https://github.com/rpcpool/yellowstone-grpc.git?tag=v1.14.1+solana.1.17.28#8fb667501cdcee0f50d8edbf5c382c97f6b4bf07" +dependencies = [ + "anyhow", + "bincode", + "prost", + "protobuf-src", + "solana-account-decoder", + "solana-sdk", + "solana-transaction-status", + "tonic", + "tonic-build", +] + +[[package]] +name = "yellowstone-grpc-tools" +version = "1.0.0-rc.11+solana.1.17.28" +source = "git+https://github.com/rpcpool/yellowstone-grpc.git?tag=v1.14.1+solana.1.17.28#8fb667501cdcee0f50d8edbf5c382c97f6b4bf07" +dependencies = [ + "anyhow", + "async-trait", + "atty", + "cargo-lock", + "clap 4.5.4", + "futures", + "git-version", + "hyper", + "json5", + "lazy_static", + "prometheus", + "serde", + "serde_json", + "serde_yaml", + "tokio", + "tokio-stream", + "tonic", + "tonic-health", + "tracing", + "tracing-subscriber", + "vergen", + "yellowstone-grpc-client", + "yellowstone-grpc-proto", +] + [[package]] name = "zerocopy" version = "0.7.32" diff --git a/Cargo.toml b/Cargo.toml index 769cf02a4..3cf0fcbfb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,7 @@ members = [ "migration", "nft_ingester", "ops", + "nft_ingester2", "program_transformers", "tools/acc_forwarder", "tools/bgtask_creator", @@ -25,18 +26,22 @@ repository = "https://github.com/metaplex-foundation/digital-asset-rpc-infrastru version = "0.7.2" [workspace.dependencies] + +backon = "0.4.1" +heck = "0.5.0" anchor-client = "0.29.0" anchor-lang = "0.29.0" anyhow = "1.0.75" async-std = "1.0.0" async-trait = "0.1.60" -backon = "0.4.1" blockbuster = "2.2.1" +atty = "0.2.14" borsh = "~0.10.3" borsh-derive = "~0.10.3" bs58 = "0.4.0" cadence = "0.29.0" cadence-macros = "0.29.0" +cargo-lock = "9.0.0" chrono = "0.4.19" clap = "4.2.2" das_api = { path = "das_api" } @@ -50,13 +55,14 @@ figment = "0.10.8" flatbuffers = "23.1.21" function_name = "0.3.0" futures = "0.3.28" -heck = "0.5.0" hex = "0.4.3" hyper = "0.14.23" indexmap = "1.9.3" indicatif = "0.17.5" insta = "1.34.0" itertools = "0.10.1" +git-version = "0.3.5" +json5 = "0.4.1" jsonpath_lib = "0.3.0" jsonrpsee = "0.16.2" jsonrpsee-core = "0.16.2" @@ -73,12 +79,16 @@ num-traits = "0.2.15" once_cell = "1.19.0" open-rpc-derive = "0.0.4" open-rpc-schema = "0.0.4" +opentelemetry = "0.21.0" +opentelemetry-jaeger = "0.20.0" +opentelemetry_sdk = "0.21.1" plerkle_messenger = "1.6.0" plerkle_serialization = "1.8.0" program_transformers = { path = "program_transformers" } prometheus = "0.13.3" proxy-wasm = "0.2.0" rand = "0.8.5" +redis = "0.25.3" regex = "1.6.0" reqwest = "0.11.13" rust-crypto = "0.2.36" @@ -89,6 +99,7 @@ sea-orm-migration = "0.10.6" sea-query = "0.28.1" serde = "1.0.137" serde_json = "1.0.81" +serde_yaml = "0.9.34" serial_test = "2.0.0" solana-account-decoder = "~1.17" solana-client = "~1.17" @@ -108,11 +119,16 @@ tokio-stream = "0.1.14" tower = "0.4.13" tower-http = "0.3.5" tracing = "0.1.35" +tracing-opentelemetry = "0.22.0" tracing-subscriber = "0.3.16" txn_forwarder = { path = "tools/txn_forwarder" } url = "2.3.1" wasi = "0.7.0" wasm-bindgen = "0.2.83" +vergen = "8.2.1" +yellowstone-grpc-client = { git = "https://github.com/rpcpool/yellowstone-grpc.git", tag = "v1.14.1+solana.1.17.28" } # tag is geyser plugin +yellowstone-grpc-proto = { git = "https://github.com/rpcpool/yellowstone-grpc.git", tag = "v1.14.1+solana.1.17.28" } # tag is geyser plugin +yellowstone-grpc-tools = { git = "https://github.com/rpcpool/yellowstone-grpc.git", tag = "v1.14.1+solana.1.17.28", default-features = false } # tag is geyser plugin [workspace.lints.clippy] clone_on_ref_ptr = "deny" diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml new file mode 100644 index 000000000..5a4e0f142 --- /dev/null +++ b/nft_ingester2/Cargo.toml @@ -0,0 +1,45 @@ +[package] +name = "nft_ingester2" +version = { workspace = true } +edition = { workspace = true } +repository = { workspace = true } +publish = { workspace = true } + +[dependencies] +anyhow = { workspace = true } +atty = { workspace = true } +clap = { workspace = true, features = ["cargo", "derive"] } +futures = { workspace = true } +hyper = { workspace = true, features = ["server"] } +json5 = { workspace = true } +lazy_static = { workspace = true } +opentelemetry = { workspace = true } +opentelemetry-jaeger = { workspace = true, features = ["rt-tokio"] } +opentelemetry_sdk = { workspace = true, features = ["trace"] } +prometheus = { workspace = true } +redis = { workspace = true, features = ["tokio-comp", "tokio-native-tls-comp"] } +serde = { workspace = true } +serde_yaml = { workspace = true } +solana-sdk = { workspace = true } # only prom rn +tokio = { workspace = true, features = [ + "rt-multi-thread", + "macros", + "time", + "fs", + "tracing", +] } +tracing = { workspace = true } +tracing-opentelemetry = { workspace = true } +tracing-subscriber = { workspace = true, features = ["env-filter", "json"] } +yellowstone-grpc-client = { workspace = true } +yellowstone-grpc-proto = { workspace = true } +yellowstone-grpc-tools = { workspace = true } + +[build-dependencies] +anyhow = { workspace = true } +cargo-lock = { workspace = true } +git-version = { workspace = true } +vergen = { workspace = true, features = ["build", "rustc"] } + +[lints] +workspace = true diff --git a/nft_ingester2/build.rs b/nft_ingester2/build.rs new file mode 100644 index 000000000..92e1f4c7c --- /dev/null +++ b/nft_ingester2/build.rs @@ -0,0 +1,38 @@ +use {cargo_lock::Lockfile, std::collections::HashSet}; + +fn main() -> anyhow::Result<()> { + let mut envs = vergen::EmitBuilder::builder(); + envs.all_build().all_rustc(); + envs.emit()?; + + // vergen git version does not looks cool + println!( + "cargo:rustc-env=GIT_VERSION={}", + git_version::git_version!() + ); + + // Extract packages version + let lockfile = Lockfile::load("../Cargo.lock")?; + println!( + "cargo:rustc-env=SOLANA_SDK_VERSION={}", + get_pkg_version(&lockfile, "solana-sdk") + ); + println!( + "cargo:rustc-env=YELLOWSTONE_GRPC_PROTO_VERSION={}", + get_pkg_version(&lockfile, "yellowstone-grpc-proto") + ); + + Ok(()) +} + +fn get_pkg_version(lockfile: &Lockfile, pkg_name: &str) -> String { + lockfile + .packages + .iter() + .filter(|pkg| pkg.name.as_str() == pkg_name) + .map(|pkg| pkg.version.to_string()) + .collect::>() + .into_iter() + .collect::>() + .join(",") +} diff --git a/nft_ingester2/config-grpc2redis.yml b/nft_ingester2/config-grpc2redis.yml new file mode 100644 index 000000000..73ed908f4 --- /dev/null +++ b/nft_ingester2/config-grpc2redis.yml @@ -0,0 +1,24 @@ +prometheus: 127.0.0.1:8873 +endpoint: http://127.0.0.1:10000 +x_token: null +commitment: processed +accounts: + stream: ACCOUNTS + stream_maxlen: 100_000_000 + stream_data_key: data + filters: + - owner: + - TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA + - metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s +transactions: + stream: TRANSACTIONS + stream_maxlen: 10_000_000 + stream_data_key: data + filters: + - account_include: + - BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY +redis: + url: redis://localhost:6379 + pipeline_max_size: 10 + pipeline_max_idle_ms: 10 + max_xadd_in_process: 100 diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs new file mode 100644 index 000000000..14b45f247 --- /dev/null +++ b/nft_ingester2/src/config.rs @@ -0,0 +1,153 @@ +use { + anyhow::Context, + serde::{de, Deserialize}, + std::{net::SocketAddr, path::Path, time::Duration}, + tokio::fs, + yellowstone_grpc_tools::config::{ + deserialize_usize_str, ConfigGrpcRequestAccounts, ConfigGrpcRequestCommitment, + ConfigGrpcRequestTransactions, + }, +}; + +pub const REDIS_STREAM_ACCOUNTS: &str = "ACCOUNTS"; +pub const REDIS_STREAM_TRANSACTIONS: &str = "TRANSACTIONS"; + +pub async fn load(path: impl AsRef + Copy) -> anyhow::Result +where + T: de::DeserializeOwned, +{ + let text = fs::read_to_string(path) + .await + .context("failed to read config from file")?; + + match path.as_ref().extension().and_then(|e| e.to_str()) { + Some("yaml") | Some("yml") => { + serde_yaml::from_str(&text).context("failed to parse config from YAML file") + } + Some("json") => json5::from_str(&text).context("failed to parse config from JSON file"), + value => anyhow::bail!("unknown config extension: {value:?}"), + } +} + +#[derive(Debug, Default, Deserialize)] +#[serde(default)] +pub struct ConfigPrometheus { + pub prometheus: Option, +} + +#[derive(Debug, Deserialize)] +pub struct ConfigGrpc { + pub endpoint: String, + pub x_token: Option, + + pub commitment: ConfigGrpcRequestCommitment, + pub accounts: ConfigGrpcAccounts, + pub transactions: ConfigGrpcTransactions, + + pub redis: ConfigGrpcRedis, +} + +#[derive(Debug, Deserialize)] +pub struct ConfigGrpcAccounts { + #[serde(default = "ConfigGrpcAccounts::default_stream")] + pub stream: String, + #[serde( + default = "ConfigGrpcAccounts::default_stream_maxlen", + deserialize_with = "deserialize_usize_str" + )] + pub stream_maxlen: usize, + #[serde(default = "ConfigGrpcAccounts::default_stream_data_key")] + pub stream_data_key: String, + + pub filters: Vec, +} + +impl ConfigGrpcAccounts { + pub fn default_stream() -> String { + REDIS_STREAM_ACCOUNTS.to_owned() + } + + pub const fn default_stream_maxlen() -> usize { + 100_000_000 + } + + pub fn default_stream_data_key() -> String { + "data".to_owned() + } +} + +#[derive(Debug, Deserialize)] +pub struct ConfigGrpcTransactions { + #[serde(default = "ConfigGrpcTransactions::default_stream")] + pub stream: String, + #[serde( + default = "ConfigGrpcTransactions::default_stream_maxlen", + deserialize_with = "deserialize_usize_str" + )] + pub stream_maxlen: usize, + #[serde(default = "ConfigGrpcTransactions::default_stream_data_key")] + pub stream_data_key: String, + + pub filters: Vec, +} + +impl ConfigGrpcTransactions { + pub fn default_stream() -> String { + REDIS_STREAM_TRANSACTIONS.to_owned() + } + + pub const fn default_stream_maxlen() -> usize { + 10_000_000 + } + + pub fn default_stream_data_key() -> String { + "data".to_owned() + } +} + +#[derive(Debug, Deserialize)] +pub struct ConfigGrpcRedis { + pub url: String, + #[serde( + default = "ConfigGrpcRedis::default_pipeline_max_size", + deserialize_with = "deserialize_usize_str" + )] + pub pipeline_max_size: usize, + #[serde( + default = "ConfigGrpcRedis::default_pipeline_max_idle_ms", + deserialize_with = "deserialize_duration_str" + )] + pub pipeline_max_idle_ms: Duration, + #[serde( + default = "ConfigGrpcRedis::max_xadd_in_process", + deserialize_with = "deserialize_usize_str" + )] + pub max_xadd_in_process: usize, +} + +impl ConfigGrpcRedis { + pub const fn default_pipeline_max_size() -> usize { + 10 + } + + pub const fn default_pipeline_max_idle_ms() -> Duration { + Duration::from_millis(10) + } + + pub const fn max_xadd_in_process() -> usize { + 100 + } +} + +pub fn deserialize_duration_str<'de, D>(deserializer: D) -> Result +where + D: de::Deserializer<'de>, +{ + let ms = deserialize_usize_str(deserializer)?; + Ok(Duration::from_millis(ms as u64)) +} + +#[derive(Debug, Deserialize)] +pub struct ConfigIngester { + // +} diff --git a/nft_ingester2/src/grpc.rs b/nft_ingester2/src/grpc.rs new file mode 100644 index 000000000..a52bc2bc7 --- /dev/null +++ b/nft_ingester2/src/grpc.rs @@ -0,0 +1,147 @@ +use { + crate::{ + config::ConfigGrpc, prom::redis_xadd_status_inc, redis::metrics_xlen, util::create_shutdown, + }, + anyhow::Context, + futures::stream::StreamExt, + redis::{streams::StreamMaxlen, RedisResult, Value as RedisValue}, + std::{sync::Arc, time::Duration}, + tokio::{ + signal::unix::SignalKind, + task::JoinSet, + time::{sleep, Instant}, + }, + yellowstone_grpc_client::GeyserGrpcClient, + yellowstone_grpc_proto::{prelude::subscribe_update::UpdateOneof, prost::Message}, +}; + +pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { + let config = Arc::new(config); + + // Connect to Redis + let client = redis::Client::open(config.redis.url.clone())?; + let connection = client.get_multiplexed_tokio_connection().await?; + + // Check stream length for the metrics + let jh_metrics_xlen = tokio::spawn({ + let connection = connection.clone(); + let streams = vec![ + config.accounts.stream.clone(), + config.transactions.stream.clone(), + ]; + async move { metrics_xlen(connection, &streams).await } + }); + tokio::pin!(jh_metrics_xlen); + + // Create gRPC client, subscribe and handle messages + let mut client = GeyserGrpcClient::build_from_shared(config.endpoint.clone())? + .x_token(config.x_token.clone())? + .connect_timeout(Duration::from_secs(10)) + .timeout(Duration::from_secs(10)) + .connect() + .await + .context("failed to connect go gRPC")?; + let (mut _subscribe_tx, mut stream) = client.subscribe().await?; + + // recv-send loop + let mut shutdown = create_shutdown()?; + let mut pipe = redis::pipe(); + let mut pipe_accounts = 0; + let mut pipe_transactions = 0; + let deadline = sleep(config.redis.pipeline_max_idle_ms); + tokio::pin!(deadline); + let mut tasks = JoinSet::new(); + + let result = loop { + tokio::select! { + biased; + result = &mut jh_metrics_xlen => match result { + Ok(Ok(_)) => unreachable!(), + Ok(Err(error)) => break Err(error), + Err(error) => break Err(error.into()), + }, + signal = &mut shutdown => { + let signal = if signal == SignalKind::interrupt() { + "SIGINT" + } else if signal == SignalKind::terminate() { + "SIGTERM" + } else { + "UNKNOWN" + }; + tracing::warn!("{signal} received, waiting spawned tasks..."); + break Ok(()); + }, + msg = stream.next() => { + match msg { + Some(Ok(msg)) => match msg.update_oneof { + Some(UpdateOneof::Account(account)) => { + pipe.xadd_maxlen( + &config.accounts.stream, + StreamMaxlen::Approx(config.accounts.stream_maxlen), + "*", + &[(&config.accounts.stream_data_key, account.encode_to_vec())], + ); + pipe_accounts += 1; + } + Some(UpdateOneof::Slot(_)) => continue, + Some(UpdateOneof::Transaction(transaction)) => { + pipe.xadd_maxlen( + &config.transactions.stream, + StreamMaxlen::Approx(config.transactions.stream_maxlen), + "*", + &[(&config.transactions.stream_data_key, transaction.encode_to_vec())] + ); + pipe_transactions += 1; + } + Some(UpdateOneof::Block(_)) => continue, + Some(UpdateOneof::Ping(_)) => continue, + Some(UpdateOneof::Pong(_)) => continue, + Some(UpdateOneof::BlockMeta(_)) => continue, + Some(UpdateOneof::Entry(_)) => continue, + Some(UpdateOneof::TransactionStatus(_)) => continue, + None => break Err(anyhow::anyhow!("received invalid update gRPC message")), + }, + Some(Err(error)) => break Err(error.into()), + None => break Err(anyhow::anyhow!("geyser gRPC request is finished")), + }; + if pipe_accounts + pipe_transactions < config.redis.pipeline_max_size { + continue; + } + }, + _ = &mut deadline => {}, + }; + + let mut pipe = std::mem::replace(&mut pipe, redis::pipe()); + let pipe_accounts = std::mem::replace(&mut pipe_accounts, 0); + let pipe_transactions = std::mem::replace(&mut pipe_transactions, 0); + deadline + .as_mut() + .reset(Instant::now() + config.redis.pipeline_max_idle_ms); + + tasks.spawn({ + let mut connection = connection.clone(); + let config = Arc::clone(&config); + async move { + let result: RedisResult = + pipe.atomic().query_async(&mut connection).await; + + let status = if result.is_ok() { Ok(()) } else { Err(()) }; + redis_xadd_status_inc(&config.accounts.stream, status, pipe_accounts); + redis_xadd_status_inc(&config.transactions.stream, status, pipe_transactions); + + Ok::<(), anyhow::Error>(()) + } + }); + while tasks.len() >= config.redis.max_xadd_in_process { + if let Some(result) = tasks.join_next().await { + result??; + } + } + }; + + while let Some(result) = tasks.join_next().await { + result??; + } + + result +} diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs new file mode 100644 index 000000000..475769af2 --- /dev/null +++ b/nft_ingester2/src/ingester.rs @@ -0,0 +1,5 @@ +use crate::config::ConfigIngester; + +pub async fn run(_config: ConfigIngester) -> anyhow::Result<()> { + todo!() +} diff --git a/nft_ingester2/src/main.rs b/nft_ingester2/src/main.rs new file mode 100644 index 000000000..7b72c18a9 --- /dev/null +++ b/nft_ingester2/src/main.rs @@ -0,0 +1,75 @@ +use { + crate::{ + config::{load as config_load, ConfigGrpc, ConfigIngester, ConfigPrometheus}, + prom::run_server as prometheus_run_server, + tracing::init as tracing_init, + }, + anyhow::Context, + clap::{Parser, Subcommand}, + std::net::SocketAddr, +}; + +mod config; +mod grpc; +mod ingester; +mod prom; +mod redis; +mod tracing; +mod util; +mod version; + +#[derive(Debug, Parser)] +#[clap(author, version)] +struct Args { + /// Path to config file + #[clap(short, long)] + config: String, + + /// Prometheus listen address + #[clap(long)] + prometheus: Option, + + #[command(subcommand)] + action: ArgsAction, +} + +#[derive(Debug, Clone, Subcommand)] +enum ArgsAction { + /// Subscribe on Geyser events using gRPC and send them to Redis + #[command(name = "grpc2redis")] + Grpc, + /// Run ingester process (process events from Redis) + #[command(name = "run")] + Ingester, +} + +#[tokio::main] +async fn main() -> anyhow::Result<()> { + tracing_init()?; + + let args = Args::parse(); + + // Run prometheus server + let config = config_load::(&args.config) + .await + .with_context(|| format!("failed to parse prometheus config from: {}", args.config))?; + if let Some(address) = args.prometheus.or(config.prometheus) { + prometheus_run_server(address)?; + } + + // Run grpc / ingester + match args.action { + ArgsAction::Grpc => { + let config = config_load::(&args.config) + .await + .with_context(|| format!("failed to parse config from: {}", args.config))?; + grpc::run(config).await + } + ArgsAction::Ingester => { + let config = config_load::(&args.config) + .await + .with_context(|| format!("failed to parse config from: {}", args.config))?; + ingester::run(config).await + } + } +} diff --git a/nft_ingester2/src/prom.rs b/nft_ingester2/src/prom.rs new file mode 100644 index 000000000..bf24a984a --- /dev/null +++ b/nft_ingester2/src/prom.rs @@ -0,0 +1,106 @@ +use { + crate::version::VERSION as VERSION_INFO, + hyper::{ + server::conn::AddrStream, + service::{make_service_fn, service_fn}, + Body, Request, Response, Server, StatusCode, + }, + prometheus::{IntCounterVec, IntGaugeVec, Opts, Registry, TextEncoder}, + std::{net::SocketAddr, sync::Once}, + tracing::{error, info}, +}; + +lazy_static::lazy_static! { + static ref REGISTRY: Registry = Registry::new(); + + static ref VERSION: IntCounterVec = IntCounterVec::new( + Opts::new("version", "Plugin version info"), + &["buildts", "git", "package", "proto", "rustc", "solana", "version"] + ).unwrap(); + + static ref REDIS_STREAM_LEN: IntGaugeVec = IntGaugeVec::new( + Opts::new("redis_stream_len", "Length of stream in Redis"), + &["stream"] + ).unwrap(); + + static ref REDIS_XADD_STATUS: IntCounterVec = IntCounterVec::new( + Opts::new("redis_xadd_status", "Status of messages sent to Redis stream"), + &["stream", "status"] + ).unwrap(); +} + +pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { + static REGISTER: Once = Once::new(); + REGISTER.call_once(|| { + macro_rules! register { + ($collector:ident) => { + REGISTRY + .register(Box::new($collector.clone())) + .expect("collector can't be registered"); + }; + } + register!(VERSION); + register!(REDIS_STREAM_LEN); + register!(REDIS_XADD_STATUS); + + VERSION + .with_label_values(&[ + VERSION_INFO.buildts, + VERSION_INFO.git, + VERSION_INFO.package, + VERSION_INFO.proto, + VERSION_INFO.rustc, + VERSION_INFO.solana, + VERSION_INFO.version, + ]) + .inc(); + }); + + let make_service = make_service_fn(move |_: &AddrStream| async move { + Ok::<_, hyper::Error>(service_fn(move |req: Request| async move { + let response = match req.uri().path() { + "/metrics" => metrics_handler(), + _ => not_found_handler(), + }; + Ok::<_, hyper::Error>(response) + })) + }); + let server = Server::try_bind(&address)?.serve(make_service); + info!("prometheus server started: {address:?}"); + tokio::spawn(async move { + if let Err(error) = server.await { + error!("prometheus server failed: {error:?}"); + } + }); + + Ok(()) +} + +fn metrics_handler() -> Response { + let metrics = TextEncoder::new() + .encode_to_string(®ISTRY.gather()) + .unwrap_or_else(|error| { + error!("could not encode custom metrics: {}", error); + String::new() + }); + Response::builder().body(Body::from(metrics)).unwrap() +} + +fn not_found_handler() -> Response { + Response::builder() + .status(StatusCode::NOT_FOUND) + .body(Body::empty()) + .unwrap() +} + +pub fn redis_stream_len_set(stream: &str, len: usize) { + REDIS_STREAM_LEN + .with_label_values(&[stream]) + .set(len as i64); +} + +pub fn redis_xadd_status_inc(stream: &str, status: Result<(), ()>, delta: usize) { + REDIS_XADD_STATUS + .with_label_values(&[stream, if status.is_ok() { "success" } else { "failed" }]) + .inc_by(delta as u64); +} diff --git a/nft_ingester2/src/redis.rs b/nft_ingester2/src/redis.rs new file mode 100644 index 000000000..9e1c16ca4 --- /dev/null +++ b/nft_ingester2/src/redis.rs @@ -0,0 +1,25 @@ +use { + crate::prom::redis_stream_len_set, + redis::AsyncCommands, + std::convert::Infallible, + tokio::time::{sleep, Duration}, +}; + +pub async fn metrics_xlen( + mut connection: C, + streams: &[String], +) -> anyhow::Result { + loop { + let mut pipe = redis::pipe(); + for stream in streams { + pipe.xlen(stream); + } + let xlens: Vec = pipe.query_async(&mut connection).await?; + + for (stream, xlen) in streams.iter().zip(xlens.into_iter()) { + redis_stream_len_set(stream, xlen); + } + + sleep(Duration::from_millis(100)).await; + } +} diff --git a/nft_ingester2/src/tracing.rs b/nft_ingester2/src/tracing.rs new file mode 100644 index 000000000..36ba4db56 --- /dev/null +++ b/nft_ingester2/src/tracing.rs @@ -0,0 +1,32 @@ +use { + opentelemetry_sdk::trace::{self, Sampler}, + std::env, + tracing_subscriber::{filter::EnvFilter, layer::SubscriberExt, util::SubscriberInitExt}, +}; + +pub fn init() -> anyhow::Result<()> { + let open_tracer = opentelemetry_jaeger::new_agent_pipeline() + .with_service_name(env::var("CARGO_PKG_NAME")?) + .with_auto_split_batch(true) + .with_trace_config(trace::config().with_sampler(Sampler::TraceIdRatioBased(0.25))) + .install_batch(opentelemetry_sdk::runtime::Tokio)?; + let jeager_layer = tracing_opentelemetry::layer().with_tracer(open_tracer); + + let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")); + + let is_atty = atty::is(atty::Stream::Stdout) && atty::is(atty::Stream::Stderr); + let io_layer = tracing_subscriber::fmt::layer().with_ansi(is_atty); + + let registry = tracing_subscriber::registry() + .with(jeager_layer) + .with(env_filter) + .with(io_layer); + + if env::var_os("RUST_LOG_JSON").is_some() { + let json_layer = tracing_subscriber::fmt::layer().json().flatten_event(true); + registry.with(json_layer).try_init() + } else { + registry.try_init() + } + .map_err(Into::into) +} diff --git a/nft_ingester2/src/util.rs b/nft_ingester2/src/util.rs new file mode 100644 index 000000000..6de97e42f --- /dev/null +++ b/nft_ingester2/src/util.rs @@ -0,0 +1,16 @@ +use { + futures::future::{BoxFuture, FutureExt}, + tokio::signal::unix::{signal, SignalKind}, +}; + +pub fn create_shutdown() -> anyhow::Result> { + let mut sigint = signal(SignalKind::interrupt())?; + let mut sigterm = signal(SignalKind::terminate())?; + Ok(async move { + tokio::select! { + _ = sigint.recv() => SignalKind::interrupt(), + _ = sigterm.recv() => SignalKind::terminate(), + } + } + .boxed()) +} diff --git a/nft_ingester2/src/version.rs b/nft_ingester2/src/version.rs new file mode 100644 index 000000000..b9da62845 --- /dev/null +++ b/nft_ingester2/src/version.rs @@ -0,0 +1,22 @@ +use {serde::Serialize, std::env}; + +#[derive(Debug, Serialize)] +pub struct Version { + pub package: &'static str, + pub version: &'static str, + pub proto: &'static str, + pub solana: &'static str, + pub git: &'static str, + pub rustc: &'static str, + pub buildts: &'static str, +} + +pub const VERSION: Version = Version { + package: env!("CARGO_PKG_NAME"), + version: env!("CARGO_PKG_VERSION"), + proto: env!("YELLOWSTONE_GRPC_PROTO_VERSION"), + solana: env!("SOLANA_SDK_VERSION"), + git: env!("GIT_VERSION"), + rustc: env!("VERGEN_RUSTC_SEMVER"), + buildts: env!("VERGEN_BUILD_TIMESTAMP"), +}; From 076bffabca6bea8be61ec22a016401e3f475bedb Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Mon, 27 Nov 2023 21:29:06 -0500 Subject: [PATCH 14/21] add redis streaming for ingester --- nft_ingester2/README.md | 33 +++ nft_ingester2/config-run.yml | 19 ++ nft_ingester2/src/config.rs | 148 +++++++++++++- nft_ingester2/src/grpc.rs | 5 +- nft_ingester2/src/ingester.rs | 75 ++++++- nft_ingester2/src/main.rs | 1 + nft_ingester2/src/postgres.rs | 1 + nft_ingester2/src/prom.rs | 22 +- nft_ingester2/src/redis.rs | 375 +++++++++++++++++++++++++++++++++- 9 files changed, 654 insertions(+), 25 deletions(-) create mode 100644 nft_ingester2/README.md create mode 100644 nft_ingester2/config-run.yml create mode 100644 nft_ingester2/src/postgres.rs diff --git a/nft_ingester2/README.md b/nft_ingester2/README.md new file mode 100644 index 000000000..a2afa2226 --- /dev/null +++ b/nft_ingester2/README.md @@ -0,0 +1,33 @@ +## Dev process + +### geyser gRPC source + +Use [Triton One](https://triton.one/) provided endpoint or run own node with geyser plugin: https://github.com/rpcpool/yellowstone-grpc + +### Redis server + +``` +redis-server +``` + +### PostgreSQL server + +Run: + +``` +docker run -it --rm -e POSTGRES_PASSWORD=solana -e POSTGRES_USER=solana -e POSTGRES_DB=solana -p 5432:5432 postgres +``` + +Schema: + +> 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. + +``` +DATABASE_URL=postgres://solana:solana@localhost/solana INIT_FILE_PATH=init.sql cargo run -p migration --bin migration -- up +``` + +psql: + +``` +PGPASSWORD=solana psql -h localhost -U solana -d solana +``` diff --git a/nft_ingester2/config-run.yml b/nft_ingester2/config-run.yml new file mode 100644 index 000000000..281f6a1fd --- /dev/null +++ b/nft_ingester2/config-run.yml @@ -0,0 +1,19 @@ +prometheus: 127.0.0.1:8874 +redis: + url: redis://localhost:6379 + group: ingester + consumer: consumer # every new ingester instance should uniq name + streams: + - type: account # possible values: `account` and `transaction`, required for message decoding + stream: ACCOUNTS + data_key: data + - type: transaction + stream: TRANSACTIONS + data_key: data + xack_batch_max_size: 100 + xack_batch_max_idle_ms: 10 + xack_max_in_process: 100 + prefetch_queue_size: 1_000 # max number of messages available in the read queue for processing + xpending_max: 250 # used for reading pending messages + xpending_only: false # exit once all pending messages consumed (should be applied if you want downscale number of ingesters) + xreadgroup_max: 1_000 # applied per each stream in one request diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs index 14b45f247..c13ea7a18 100644 --- a/nft_ingester2/src/config.rs +++ b/nft_ingester2/src/config.rs @@ -11,6 +11,7 @@ use { pub const REDIS_STREAM_ACCOUNTS: &str = "ACCOUNTS"; pub const REDIS_STREAM_TRANSACTIONS: &str = "TRANSACTIONS"; +pub const REDIS_STREAM_DATA_KEY: &str = "data"; pub async fn load(path: impl AsRef + Copy) -> anyhow::Result where @@ -72,7 +73,7 @@ impl ConfigGrpcAccounts { } pub fn default_stream_data_key() -> String { - "data".to_owned() + REDIS_STREAM_DATA_KEY.to_owned() } } @@ -101,7 +102,7 @@ impl ConfigGrpcTransactions { } pub fn default_stream_data_key() -> String { - "data".to_owned() + REDIS_STREAM_DATA_KEY.to_owned() } } @@ -114,12 +115,13 @@ pub struct ConfigGrpcRedis { )] pub pipeline_max_size: usize, #[serde( - default = "ConfigGrpcRedis::default_pipeline_max_idle_ms", - deserialize_with = "deserialize_duration_str" + default = "ConfigGrpcRedis::default_pipeline_max_idle", + deserialize_with = "deserialize_duration_str", + rename = "pipeline_max_idle_ms" )] - pub pipeline_max_idle_ms: Duration, + pub pipeline_max_idle: Duration, #[serde( - default = "ConfigGrpcRedis::max_xadd_in_process", + default = "ConfigGrpcRedis::default_max_xadd_in_process", deserialize_with = "deserialize_usize_str" )] pub max_xadd_in_process: usize, @@ -130,11 +132,11 @@ impl ConfigGrpcRedis { 10 } - pub const fn default_pipeline_max_idle_ms() -> Duration { + pub const fn default_pipeline_max_idle() -> Duration { Duration::from_millis(10) } - pub const fn max_xadd_in_process() -> usize { + pub const fn default_max_xadd_in_process() -> usize { 100 } } @@ -149,5 +151,133 @@ where #[derive(Debug, Deserialize)] pub struct ConfigIngester { - // + pub redis: ConfigIngesterRedis, +} + +#[derive(Debug, Deserialize)] +pub struct ConfigIngesterRedis { + pub url: String, + #[serde(default = "ConfigIngesterRedis::default_group")] + pub group: String, + #[serde(default = "ConfigIngesterRedis::default_consumer")] + pub consumer: String, + pub streams: Vec, + #[serde( + default = "ConfigIngesterRedis::default_prefetch_queue_size", + deserialize_with = "deserialize_usize_str" + )] + pub prefetch_queue_size: usize, + #[serde( + default = "ConfigIngesterRedis::default_xpending_max", + deserialize_with = "deserialize_usize_str" + )] + pub xpending_max: usize, + #[serde(default = "ConfigIngesterRedis::default_xpending_only")] + pub xpending_only: bool, + #[serde( + default = "ConfigIngesterRedis::default_xreadgroup_max", + deserialize_with = "deserialize_usize_str" + )] + pub xreadgroup_max: usize, +} + +impl ConfigIngesterRedis { + pub fn default_group() -> String { + "ingester".to_owned() + } + + pub fn default_consumer() -> String { + "consumer".to_owned() + } + + pub const fn default_prefetch_queue_size() -> usize { + 1_000 + } + + pub const fn default_xpending_max() -> usize { + 100 + } + + pub const fn default_xpending_only() -> bool { + false + } + + pub const fn default_xreadgroup_max() -> usize { + 1_000 + } +} + +#[derive(Debug, Clone)] +pub struct ConfigIngesterRedisStream { + pub stream_type: ConfigIngesterRedisStreamType, + pub stream: String, + pub data_key: String, + pub xack_batch_max_size: usize, + pub xack_batch_max_idle: Duration, + pub xack_max_in_process: usize, +} + +impl<'de> Deserialize<'de> for ConfigIngesterRedisStream { + fn deserialize(deserializer: D) -> Result + where + D: de::Deserializer<'de>, + { + #[derive(Debug, Deserialize)] + struct Raw { + #[serde(rename = "type")] + pub stream_type: ConfigIngesterRedisStreamType, + pub stream: Option, + pub data_key: Option, + #[serde( + default = "default_xack_batch_max_size", + deserialize_with = "deserialize_usize_str" + )] + pub xack_batch_max_size: usize, + #[serde( + default = "default_xack_batch_max_idle", + deserialize_with = "deserialize_duration_str", + rename = "xack_batch_max_idle_ms" + )] + pub xack_batch_max_idle: Duration, + #[serde( + default = "default_xack_max_in_process", + deserialize_with = "deserialize_usize_str" + )] + pub xack_max_in_process: usize, + } + + const fn default_xack_batch_max_size() -> usize { + 100 + } + + const fn default_xack_batch_max_idle() -> Duration { + Duration::from_millis(10) + } + + const fn default_xack_max_in_process() -> usize { + 100 + } + + let raw = Raw::deserialize(deserializer)?; + Ok(Self { + stream_type: raw.stream_type, + stream: raw.stream.unwrap_or_else(|| match raw.stream_type { + ConfigIngesterRedisStreamType::Account => REDIS_STREAM_ACCOUNTS.to_owned(), + ConfigIngesterRedisStreamType::Transaction => REDIS_STREAM_TRANSACTIONS.to_owned(), + }), + data_key: raw + .data_key + .unwrap_or_else(|| REDIS_STREAM_DATA_KEY.to_owned()), + xack_batch_max_size: raw.xack_batch_max_size, + xack_batch_max_idle: raw.xack_batch_max_idle, + xack_max_in_process: raw.xack_max_in_process, + }) + } +} + +#[derive(Debug, Deserialize, Clone, Copy, PartialEq, Eq)] +#[serde(rename_all = "lowercase")] +pub enum ConfigIngesterRedisStreamType { + Account, + Transaction, } diff --git a/nft_ingester2/src/grpc.rs b/nft_ingester2/src/grpc.rs index a52bc2bc7..aebb88b8a 100644 --- a/nft_ingester2/src/grpc.rs +++ b/nft_ingester2/src/grpc.rs @@ -48,13 +48,12 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { let mut pipe = redis::pipe(); let mut pipe_accounts = 0; let mut pipe_transactions = 0; - let deadline = sleep(config.redis.pipeline_max_idle_ms); + let deadline = sleep(config.redis.pipeline_max_idle); tokio::pin!(deadline); let mut tasks = JoinSet::new(); let result = loop { tokio::select! { - biased; result = &mut jh_metrics_xlen => match result { Ok(Ok(_)) => unreachable!(), Ok(Err(error)) => break Err(error), @@ -116,7 +115,7 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { let pipe_transactions = std::mem::replace(&mut pipe_transactions, 0); deadline .as_mut() - .reset(Instant::now() + config.redis.pipeline_max_idle_ms); + .reset(Instant::now() + config.redis.pipeline_max_idle); tasks.spawn({ let mut connection = connection.clone(); diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 475769af2..1e02e03ed 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -1,5 +1,74 @@ -use crate::config::ConfigIngester; +use { + crate::{ + config::ConfigIngester, + redis::{metrics_xlen, RedisStream}, + util::create_shutdown, + }, + futures::future::{Fuse, FusedFuture, FutureExt}, + tokio::signal::unix::SignalKind, +}; -pub async fn run(_config: ConfigIngester) -> anyhow::Result<()> { - todo!() +pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { + println!("{:#?}", config); + + // connect to Redis + let client = redis::Client::open(config.redis.url.clone())?; + let connection = client.get_multiplexed_tokio_connection().await?; + + // check stream length for the metrics in spawned task + let jh_metrics_xlen = tokio::spawn({ + let connection = connection.clone(); + let streams = config + .redis + .streams + .iter() + .map(|config| config.stream.clone()) + .collect::>(); + async move { metrics_xlen(connection, &streams).await } + }); + tokio::pin!(jh_metrics_xlen); + + // create redis stream reader + let (mut redis_messages, redis_tasks) = RedisStream::new(config.redis, connection).await?; + let redis_tasks_fut = Fuse::terminated(); + tokio::pin!(redis_tasks_fut); + redis_tasks_fut.set(redis_tasks.fuse()); + + // read messages in the loop + let mut shutdown = create_shutdown()?; + let result = loop { + tokio::select! { + result = &mut jh_metrics_xlen => match result { + Ok(Ok(_)) => unreachable!(), + Ok(Err(error)) => break Err(error), + Err(error) => break Err(error.into()), + }, + signal = &mut shutdown => { + let signal = if signal == SignalKind::interrupt() { + "SIGINT" + } else if signal == SignalKind::terminate() { + "SIGTERM" + } else { + "UNKNOWN" + }; + tracing::warn!("{signal} received, waiting spawned tasks..."); + break Ok(()); + }, + result = &mut redis_tasks_fut => break result, + msg = redis_messages.recv() => match msg { + Some(msg) => { + // TODO: process messages here + msg.ack()?; + } + None => break Ok(()), + } + }; + }; + + redis_messages.shutdown(); + if !redis_tasks_fut.is_terminated() { + redis_tasks_fut.await?; + } + + result } diff --git a/nft_ingester2/src/main.rs b/nft_ingester2/src/main.rs index 7b72c18a9..0bd1f9b8d 100644 --- a/nft_ingester2/src/main.rs +++ b/nft_ingester2/src/main.rs @@ -12,6 +12,7 @@ use { mod config; mod grpc; mod ingester; +mod postgres; mod prom; mod redis; mod tracing; diff --git a/nft_ingester2/src/postgres.rs b/nft_ingester2/src/postgres.rs new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/nft_ingester2/src/postgres.rs @@ -0,0 +1 @@ + diff --git a/nft_ingester2/src/prom.rs b/nft_ingester2/src/prom.rs index bf24a984a..b6794b615 100644 --- a/nft_ingester2/src/prom.rs +++ b/nft_ingester2/src/prom.rs @@ -18,8 +18,8 @@ lazy_static::lazy_static! { &["buildts", "git", "package", "proto", "rustc", "solana", "version"] ).unwrap(); - static ref REDIS_STREAM_LEN: IntGaugeVec = IntGaugeVec::new( - Opts::new("redis_stream_len", "Length of stream in Redis"), + static ref REDIS_XLEN_TOTAL: IntGaugeVec = IntGaugeVec::new( + Opts::new("redis_xlen_total", "Length of stream in Redis"), &["stream"] ).unwrap(); @@ -27,6 +27,11 @@ lazy_static::lazy_static! { Opts::new("redis_xadd_status", "Status of messages sent to Redis stream"), &["stream", "status"] ).unwrap(); + + static ref REDIS_XACK_TOTAL: IntCounterVec = IntCounterVec::new( + Opts::new("redis_xack_total", "Total number of processed messages"), + &["stream"] + ).unwrap(); } pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { @@ -40,8 +45,9 @@ pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { }; } register!(VERSION); - register!(REDIS_STREAM_LEN); + register!(REDIS_XLEN_TOTAL); register!(REDIS_XADD_STATUS); + register!(REDIS_XACK_TOTAL); VERSION .with_label_values(&[ @@ -93,8 +99,8 @@ fn not_found_handler() -> Response { .unwrap() } -pub fn redis_stream_len_set(stream: &str, len: usize) { - REDIS_STREAM_LEN +pub fn redis_xlen_set(stream: &str, len: usize) { + REDIS_XLEN_TOTAL .with_label_values(&[stream]) .set(len as i64); } @@ -104,3 +110,9 @@ pub fn redis_xadd_status_inc(stream: &str, status: Result<(), ()>, delta: usize) .with_label_values(&[stream, if status.is_ok() { "success" } else { "failed" }]) .inc_by(delta as u64); } + +pub fn redis_xack_inc(stream: &str, delta: usize) { + REDIS_XACK_TOTAL + .with_label_values(&[stream]) + .inc_by(delta as u64) +} diff --git a/nft_ingester2/src/redis.rs b/nft_ingester2/src/redis.rs index 9e1c16ca4..47f4584f3 100644 --- a/nft_ingester2/src/redis.rs +++ b/nft_ingester2/src/redis.rs @@ -1,8 +1,34 @@ use { - crate::prom::redis_stream_len_set, - redis::AsyncCommands, - std::convert::Infallible, - tokio::time::{sleep, Duration}, + crate::{ + config::{ConfigIngesterRedis, ConfigIngesterRedisStreamType}, + prom::{redis_xack_inc, redis_xlen_set}, + }, + futures::future::{BoxFuture, FutureExt}, + redis::{ + aio::MultiplexedConnection, + streams::{ + StreamClaimReply, StreamId, StreamKey, StreamPendingCountReply, StreamReadOptions, + StreamReadReply, + }, + AsyncCommands, ErrorKind as RedisErrorKind, RedisResult, Value as RedisValue, + }, + std::{ + collections::HashMap, + convert::Infallible, + sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }, + }, + tokio::{ + sync::mpsc, + task::JoinSet, + time::{sleep, Duration, Instant}, + }, + yellowstone_grpc_proto::{ + prelude::{SubscribeUpdateAccount, SubscribeUpdateTransaction}, + prost::Message, + }, }; pub async fn metrics_xlen( @@ -17,9 +43,348 @@ pub async fn metrics_xlen( let xlens: Vec = pipe.query_async(&mut connection).await?; for (stream, xlen) in streams.iter().zip(xlens.into_iter()) { - redis_stream_len_set(stream, xlen); + redis_xlen_set(stream, xlen); } sleep(Duration::from_millis(100)).await; } } + +pub async fn xgroup_create( + connection: &mut C, + name: &str, + group: &str, + consumer: &str, +) -> anyhow::Result<()> { + let result: RedisResult = connection.xgroup_create_mkstream(name, group, "0").await; + if let Err(error) = result { + if !(error.kind() == RedisErrorKind::ExtensionError + && error.detail() == Some("Consumer Group name already exists") + && error.code() == Some("BUSYGROUP")) + { + return Err(error.into()); + } + } + + // XGROUP CREATECONSUMER key group consumer + redis::cmd("XGROUP") + .arg("CREATECONSUMER") + .arg(name) + .arg(group) + .arg(consumer) + .query_async(connection) + .await?; + + Ok(()) +} + +#[derive(Debug)] +struct RedisStreamInfo { + group: String, + consumer: String, + stream_name: String, + stream_type: ConfigIngesterRedisStreamType, + stream_data_key: String, + xack_batch_max_size: usize, + xack_batch_max_idle: Duration, + xack_max_in_process: usize, +} + +#[allow(clippy::large_enum_variant)] +#[derive(Debug)] +pub enum RedisStreamMessage { + Account(SubscribeUpdateAccount), + Transaction(SubscribeUpdateTransaction), +} + +#[derive(Debug)] +pub struct RedisStreamMessageInfo { + id: String, + data: RedisStreamMessage, + ack_tx: mpsc::UnboundedSender, +} + +impl RedisStreamMessageInfo { + fn parse( + stream: &RedisStreamInfo, + StreamId { id, map }: StreamId, + ack_tx: mpsc::UnboundedSender, + ) -> anyhow::Result { + let data = match map.get(&stream.stream_data_key) { + Some(RedisValue::Data(vec)) => match stream.stream_type { + ConfigIngesterRedisStreamType::Account => { + RedisStreamMessage::Account(SubscribeUpdateAccount::decode(vec.as_ref())?) + } + ConfigIngesterRedisStreamType::Transaction => RedisStreamMessage::Transaction( + SubscribeUpdateTransaction::decode(vec.as_ref())?, + ), + }, + Some(_) => anyhow::bail!( + "invalid data (key: {:?}) from stream {:?}", + stream.stream_data_key, + stream.stream_name + ), + None => anyhow::bail!( + "failed to get data (key: {:?}) from stream {:?}", + stream.stream_data_key, + stream.stream_name + ), + }; + Ok(Self { id, data, ack_tx }) + } + + pub fn ack(self) -> anyhow::Result<()> { + self.ack_tx + .send(self.id) + .map_err(|_error| anyhow::anyhow!("failed to send message to ack channel",)) + } +} + +#[derive(Debug)] +pub struct RedisStream { + shutdown: Arc, + messages_rx: mpsc::Receiver, +} + +impl RedisStream { + pub async fn new( + config: ConfigIngesterRedis, + mut connection: MultiplexedConnection, + ) -> anyhow::Result<(Self, BoxFuture<'static, anyhow::Result<()>>)> { + // create group with consumer per stream + for stream in config.streams.iter() { + xgroup_create( + &mut connection, + &stream.stream, + &config.group, + &config.consumer, + ) + .await?; + } + + // shutdown flag + let shutdown = Arc::new(AtomicBool::new(false)); + + // create stream info wrapped by Arc + let mut ack_tasks = vec![]; + let streams = config + .streams + .iter() + .map(|stream| { + let (ack_tx, ack_rx) = mpsc::unbounded_channel(); + let info = Arc::new(RedisStreamInfo { + group: config.group.clone(), + consumer: config.consumer.clone(), + stream_name: stream.stream.clone(), + stream_type: stream.stream_type, + stream_data_key: stream.data_key.clone(), + xack_batch_max_size: stream.xack_batch_max_size, + xack_batch_max_idle: stream.xack_batch_max_idle, + xack_max_in_process: stream.xack_max_in_process, + }); + ack_tasks.push((Arc::clone(&info), ack_rx)); + (stream.stream.clone(), (ack_tx, info)) + }) + .collect::>(); + + // spawn ack tasks + let mut tasks = ack_tasks + .into_iter() + .map(|(stream, ack_rx)| { + let connection = connection.clone(); + tokio::spawn(async move { Self::run_ack(stream, connection, ack_rx).await }) + }) + .collect::>(); + + // spawn prefetch task + let (messages_tx, messages_rx) = mpsc::channel(config.prefetch_queue_size); + tasks.push(tokio::spawn({ + let shutdown = Arc::clone(&shutdown); + async move { Self::run_prefetch(config, streams, connection, messages_tx, shutdown).await } + })); + + // merge spawn tasks + let spawned_tasks = async move { + for task in tasks.into_iter() { + task.await??; + } + Ok::<(), anyhow::Error>(()) + } + .boxed(); + + Ok(( + Self { + shutdown, + messages_rx, + }, + spawned_tasks, + )) + } + + pub async fn recv(&mut self) -> Option { + self.messages_rx.recv().await + } + + pub fn shutdown(self) { + self.shutdown.store(true, Ordering::Relaxed); + } + + async fn run_prefetch( + config: ConfigIngesterRedis, + streams: HashMap, Arc)>, + mut connection: MultiplexedConnection, + messages_tx: mpsc::Sender, + shutdown: Arc, + ) -> anyhow::Result<()> { + // read pending first + for (ack_tx, stream) in streams.values() { + let mut start = "-".to_owned(); + while !shutdown.load(Ordering::Relaxed) { + let StreamPendingCountReply { ids: pending_ids } = redis::cmd("XPENDING") + .arg(&stream.stream_name) + .arg(&stream.group) + .arg(&start) + .arg("+") + .arg(config.xpending_max) + .arg(&stream.consumer) // we can't use `xpending_count` because it doesn't support `consumer` filter + .query_async(&mut connection) + .await?; + + // drop first item if we do not start from the beginning + let used_ids = if start == "-" { 0.. } else { 1.. }; + let ids_str = pending_ids[used_ids] + .iter() + .map(|pending| pending.id.as_str()) + .collect::>(); + + // check that we fetched all pendings and update start + match pending_ids.last() { + Some(id) => { + if id.id == start { + break; + } else { + start = id.id.clone(); + } + } + None => break, + } + + // read pending keys + let StreamClaimReply { ids: pendings } = connection + .xclaim( + &stream.stream_name, + &stream.group, + &stream.consumer, + 0, + &ids_str, + ) + .await?; + for pending in pendings { + let item = RedisStreamMessageInfo::parse(stream, pending, ack_tx.clone())?; + messages_tx.send(item).await.map_err(|_error| { + anyhow::anyhow!("failed to send item to prefetch channel") + })?; + } + } + } + + // exit if need to handle only pending + if config.xpending_only { + return Ok(()); + } + + let streams_keys = streams.keys().map(|name| name.as_str()).collect::>(); + let streams_ids = (0..streams_keys.len()).map(|_| ">").collect::>(); + while !shutdown.load(Ordering::Relaxed) { + let opts = StreamReadOptions::default() + .count(config.xreadgroup_max) + .group(&config.group, &config.consumer); + let results: StreamReadReply = connection + .xread_options(&streams_keys, &streams_ids, &opts) + .await?; + if results.keys.is_empty() { + sleep(Duration::from_millis(5)).await; + continue; + } + + for StreamKey { key, ids } in results.keys { + let (ack_tx, stream) = match streams.get(&key) { + Some(value) => value, + None => anyhow::bail!("unknown stream: {:?}", key), + }; + + for id in ids { + let item = RedisStreamMessageInfo::parse(stream, id, ack_tx.clone())?; + messages_tx.send(item).await.map_err(|_error| { + anyhow::anyhow!("failed to send item to prefetch channel") + })?; + } + } + } + + Ok(()) + } + + async fn run_ack( + stream: Arc, + connection: MultiplexedConnection, + mut ack_rx: mpsc::UnboundedReceiver, + ) -> anyhow::Result<()> { + let mut ids = vec![]; + let deadline = sleep(stream.xack_batch_max_idle); + tokio::pin!(deadline); + let mut tasks = JoinSet::new(); + + let result = loop { + let terminated = tokio::select! { + msg = ack_rx.recv() => match msg { + Some(msg) => { + ids.push(msg); + if ids.len() < stream.xack_batch_max_size { + continue; + } + false + } + None => true, + }, + _ = &mut deadline => false, + }; + + let ids = std::mem::take(&mut ids); + deadline + .as_mut() + .reset(Instant::now() + stream.xack_batch_max_idle); + if !ids.is_empty() { + tasks.spawn({ + let stream = Arc::clone(&stream); + let mut connection = connection.clone(); + async move { + redis::pipe() + .atomic() + .xack(&stream.stream_name, &stream.group, &ids) + .xdel(&stream.stream_name, &ids) + .query_async(&mut connection) + .await?; + redis_xack_inc(&stream.stream_name, ids.len()); + Ok::<(), anyhow::Error>(()) + } + }); + while tasks.len() >= stream.xack_max_in_process { + if let Some(result) = tasks.join_next().await { + result??; + } + } + } + + if terminated { + break Ok(()); + } + }; + + while let Some(result) = tasks.join_next().await { + result??; + } + + result + } +} From d8673cf38f37f5eeac6d711b1b06823dfa483844 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Tue, 28 Nov 2023 21:57:16 -0500 Subject: [PATCH 15/21] create pg pool --- Cargo.lock | 1 + nft_ingester2/Cargo.toml | 1 + nft_ingester2/config-run.yml | 6 +++++- nft_ingester2/src/config.rs | 26 ++++++++++++++++++++++++++ nft_ingester2/src/ingester.rs | 17 +++++++++++++++++ nft_ingester2/src/postgres.rs | 30 ++++++++++++++++++++++++++++++ nft_ingester2/src/prom.rs | 21 +++++++++++++++++++++ nft_ingester2/src/redis.rs | 6 +++--- 8 files changed, 104 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index debbc5287..1d35a7e83 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3738,6 +3738,7 @@ dependencies = [ "opentelemetry", "opentelemetry-jaeger", "opentelemetry_sdk", + "program_transformers", "prometheus", "redis 0.25.3", "serde", diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml index 5a4e0f142..b58975c1c 100644 --- a/nft_ingester2/Cargo.toml +++ b/nft_ingester2/Cargo.toml @@ -16,6 +16,7 @@ lazy_static = { workspace = true } opentelemetry = { workspace = true } opentelemetry-jaeger = { workspace = true, features = ["rt-tokio"] } opentelemetry_sdk = { workspace = true, features = ["trace"] } +program_transformers = { workspace = true } prometheus = { workspace = true } redis = { workspace = true, features = ["tokio-comp", "tokio-native-tls-comp"] } serde = { workspace = true } diff --git a/nft_ingester2/config-run.yml b/nft_ingester2/config-run.yml index 281f6a1fd..3acd4ea24 100644 --- a/nft_ingester2/config-run.yml +++ b/nft_ingester2/config-run.yml @@ -2,7 +2,7 @@ prometheus: 127.0.0.1:8874 redis: url: redis://localhost:6379 group: ingester - consumer: consumer # every new ingester instance should uniq name + consumer: consumer # every new ingester instance should have uniq name streams: - type: account # possible values: `account` and `transaction`, required for message decoding stream: ACCOUNTS @@ -17,3 +17,7 @@ redis: xpending_max: 250 # used for reading pending messages xpending_only: false # exit once all pending messages consumed (should be applied if you want downscale number of ingesters) xreadgroup_max: 1_000 # applied per each stream in one request +postgres: + url: postgres://solana:solana@localhost/solana + min_connections: 10 + max_connections: 25 diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs index c13ea7a18..a79c167d4 100644 --- a/nft_ingester2/src/config.rs +++ b/nft_ingester2/src/config.rs @@ -152,6 +152,7 @@ where #[derive(Debug, Deserialize)] pub struct ConfigIngester { pub redis: ConfigIngesterRedis, + pub postgres: ConfigIngesterPostgres, } #[derive(Debug, Deserialize)] @@ -281,3 +282,28 @@ pub enum ConfigIngesterRedisStreamType { Account, Transaction, } + +#[derive(Debug, Deserialize)] +pub struct ConfigIngesterPostgres { + pub url: String, + #[serde( + default = "ConfigIngesterPostgres::default_min_connections", + deserialize_with = "deserialize_usize_str" + )] + pub min_connections: usize, + #[serde( + default = "ConfigIngesterPostgres::default_max_connections", + deserialize_with = "deserialize_usize_str" + )] + pub max_connections: usize, +} + +impl ConfigIngesterPostgres { + pub const fn default_min_connections() -> usize { + 10 + } + + pub const fn default_max_connections() -> usize { + 25 + } +} diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 1e02e03ed..054be0d5a 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -1,10 +1,13 @@ use { crate::{ config::ConfigIngester, + postgres::{create_pool as pg_create_pool, metrics_pgpool}, redis::{metrics_xlen, RedisStream}, util::create_shutdown, }, futures::future::{Fuse, FusedFuture, FutureExt}, + program_transformers::ProgramTransformer, + std::sync::Arc, tokio::signal::unix::SignalKind, }; @@ -28,6 +31,13 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { }); tokio::pin!(jh_metrics_xlen); + // open connection to postgres + let pgpool = pg_create_pool(config.postgres).await?; + tokio::spawn({ + let pgpool = Arc::clone(&pgpool); + async move { metrics_pgpool(pgpool).await } + }); + // create redis stream reader let (mut redis_messages, redis_tasks) = RedisStream::new(config.redis, connection).await?; let redis_tasks_fut = Fuse::terminated(); @@ -69,6 +79,13 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { if !redis_tasks_fut.is_terminated() { redis_tasks_fut.await?; } + pgpool.close().await; result } + +async fn run_program_transformers() -> anyhow::Result<()> { + // let pt_accounts = ProgramTransformer::new() + + todo!() +} diff --git a/nft_ingester2/src/postgres.rs b/nft_ingester2/src/postgres.rs index 8b1378917..6f7bc3c0d 100644 --- a/nft_ingester2/src/postgres.rs +++ b/nft_ingester2/src/postgres.rs @@ -1 +1,31 @@ +use { + crate::{ + config::ConfigIngesterPostgres, + prom::{pgpool_connections_set, PgpoolConnectionsKind}, + }, + sqlx::{ + postgres::{PgConnectOptions, PgPoolOptions}, + PgPool, + }, + std::sync::Arc, + tokio::time::{sleep, Duration}, +}; +pub async fn create_pool(config: ConfigIngesterPostgres) -> anyhow::Result> { + let options: PgConnectOptions = config.url.parse()?; + PgPoolOptions::new() + .min_connections(config.min_connections.try_into()?) + .max_connections(config.max_connections.try_into()?) + .connect_with(options) + .await + .map(Arc::new) + .map_err(Into::into) +} + +pub async fn metrics_pgpool(pgpool: Arc) { + loop { + pgpool_connections_set(PgpoolConnectionsKind::Total, pgpool.size() as usize); + pgpool_connections_set(PgpoolConnectionsKind::Idle, pgpool.num_idle()); + sleep(Duration::from_millis(100)).await; + } +} diff --git a/nft_ingester2/src/prom.rs b/nft_ingester2/src/prom.rs index b6794b615..1b048671e 100644 --- a/nft_ingester2/src/prom.rs +++ b/nft_ingester2/src/prom.rs @@ -32,6 +32,11 @@ lazy_static::lazy_static! { Opts::new("redis_xack_total", "Total number of processed messages"), &["stream"] ).unwrap(); + + static ref PGPOOL_CONNECTIONS_TOTAL: IntGaugeVec = IntGaugeVec::new( + Opts::new("pgpool_connections_total", "Total number of connections in Postgres Pool"), + &["kind"] + ).unwrap(); } pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { @@ -48,6 +53,7 @@ pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { register!(REDIS_XLEN_TOTAL); register!(REDIS_XADD_STATUS); register!(REDIS_XACK_TOTAL); + register!(PGPOOL_CONNECTIONS_TOTAL); VERSION .with_label_values(&[ @@ -116,3 +122,18 @@ pub fn redis_xack_inc(stream: &str, delta: usize) { .with_label_values(&[stream]) .inc_by(delta as u64) } + +#[derive(Debug, Clone, Copy)] +pub enum PgpoolConnectionsKind { + Total, + Idle, +} + +pub fn pgpool_connections_set(kind: PgpoolConnectionsKind, size: usize) { + PGPOOL_CONNECTIONS_TOTAL + .with_label_values(&[match kind { + PgpoolConnectionsKind::Total => "total", + PgpoolConnectionsKind::Idle => "idle", + }]) + .set(size as i64) +} diff --git a/nft_ingester2/src/redis.rs b/nft_ingester2/src/redis.rs index 47f4584f3..554f02c6e 100644 --- a/nft_ingester2/src/redis.rs +++ b/nft_ingester2/src/redis.rs @@ -136,7 +136,7 @@ impl RedisStreamMessageInfo { pub fn ack(self) -> anyhow::Result<()> { self.ack_tx .send(self.id) - .map_err(|_error| anyhow::anyhow!("failed to send message to ack channel",)) + .map_err(|_error| anyhow::anyhow!("failed to send message to ack channel")) } } @@ -187,7 +187,7 @@ impl RedisStream { }) .collect::>(); - // spawn ack tasks + // spawn xack tasks let mut tasks = ack_tasks .into_iter() .map(|(stream, ack_rx)| { @@ -203,7 +203,7 @@ impl RedisStream { async move { Self::run_prefetch(config, streams, connection, messages_tx, shutdown).await } })); - // merge spawn tasks + // merge spawned xack / prefetch tasks let spawned_tasks = async move { for task in tasks.into_iter() { task.await??; From c93adffc6e5dde712e1469af06b651ea00ce6cbe Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Tue, 28 Nov 2023 23:01:47 -0500 Subject: [PATCH 16/21] parse incoming message from redis --- Cargo.lock | 1 + nft_ingester2/Cargo.toml | 8 ++ nft_ingester2/config-run.yml | 3 + nft_ingester2/src/config.rs | 22 +++++ nft_ingester2/src/ingester.rs | 171 +++++++++++++++++++++++++++++----- nft_ingester2/src/postgres.rs | 6 +- nft_ingester2/src/prom.rs | 36 ++++++- nft_ingester2/src/redis.rs | 90 +++++++++++++++--- 8 files changed, 297 insertions(+), 40 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1d35a7e83..fd708440f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3744,6 +3744,7 @@ dependencies = [ "serde", "serde_yaml", "solana-sdk", + "sqlx", "tokio", "tracing", "tracing-opentelemetry", diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml index b58975c1c..455f2902d 100644 --- a/nft_ingester2/Cargo.toml +++ b/nft_ingester2/Cargo.toml @@ -8,6 +8,14 @@ publish = { workspace = true } [dependencies] anyhow = { workspace = true } atty = { workspace = true } +sqlx = { workspace = true, features = [ + "macros", + "runtime-tokio-rustls", + "postgres", + "uuid", + "offline", + "json", +] } clap = { workspace = true, features = ["cargo", "derive"] } futures = { workspace = true } hyper = { workspace = true, features = ["server"] } diff --git a/nft_ingester2/config-run.yml b/nft_ingester2/config-run.yml index 3acd4ea24..19a1b3f84 100644 --- a/nft_ingester2/config-run.yml +++ b/nft_ingester2/config-run.yml @@ -21,3 +21,6 @@ postgres: url: postgres://solana:solana@localhost/solana min_connections: 10 max_connections: 25 +program_transformer: + transactions_cl_audits: false + max_tasks_in_process: 100 diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs index a79c167d4..003985f27 100644 --- a/nft_ingester2/src/config.rs +++ b/nft_ingester2/src/config.rs @@ -153,6 +153,7 @@ where pub struct ConfigIngester { pub redis: ConfigIngesterRedis, pub postgres: ConfigIngesterPostgres, + pub program_transformer: ConfigIngesterProgramTransformer, } #[derive(Debug, Deserialize)] @@ -307,3 +308,24 @@ impl ConfigIngesterPostgres { 25 } } + +#[derive(Debug, Deserialize)] +pub struct ConfigIngesterProgramTransformer { + #[serde(default = "ConfigIngesterProgramTransformer::default_transactions_cl_audits")] + pub transactions_cl_audits: bool, + #[serde( + default = "ConfigIngesterProgramTransformer::default_max_tasks_in_process", + deserialize_with = "deserialize_usize_str" + )] + pub max_tasks_in_process: usize, +} + +impl ConfigIngesterProgramTransformer { + pub const fn default_transactions_cl_audits() -> bool { + false + } + + pub const fn default_max_tasks_in_process() -> usize { + 100 + } +} diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 054be0d5a..0d7d43478 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -2,13 +2,28 @@ use { crate::{ config::ConfigIngester, postgres::{create_pool as pg_create_pool, metrics_pgpool}, - redis::{metrics_xlen, RedisStream}, + prom::{ + program_transformer_task_status_inc, program_transformer_tasks_total_set, + ProgramTransformerTaskStatusKind, + }, + redis::{metrics_xlen, ProgramTransformerInfo, RedisStream}, util::create_shutdown, }, - futures::future::{Fuse, FusedFuture, FutureExt}, - program_transformers::ProgramTransformer, - std::sync::Arc, - tokio::signal::unix::SignalKind, + futures::future::{pending, BoxFuture, FusedFuture, FutureExt}, + program_transformers::{ + error::ProgramTransformerError, DownloadMetadataInfo, DownloadMetadataNotifier, + ProgramTransformer, + }, + std::sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }, + tokio::{ + signal::unix::SignalKind, + task::JoinSet, + time::{sleep, Duration}, + }, + tracing::warn, }; pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { @@ -34,20 +49,55 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { // open connection to postgres let pgpool = pg_create_pool(config.postgres).await?; tokio::spawn({ - let pgpool = Arc::clone(&pgpool); + let pgpool = pgpool.clone(); async move { metrics_pgpool(pgpool).await } }); // create redis stream reader - let (mut redis_messages, redis_tasks) = RedisStream::new(config.redis, connection).await?; - let redis_tasks_fut = Fuse::terminated(); + let (mut redis_messages, redis_tasks_fut) = RedisStream::new(config.redis, connection).await?; tokio::pin!(redis_tasks_fut); - redis_tasks_fut.set(redis_tasks.fuse()); - // read messages in the loop + // program transforms related + let pt_accounts = Arc::new(ProgramTransformer::new( + pgpool.clone(), + create_notifier(), + false, + )); + let pt_transactions = Arc::new(ProgramTransformer::new( + pgpool.clone(), + create_notifier(), + config.program_transformer.transactions_cl_audits, + )); + let pt_max_tasks_in_process = config.program_transformer.max_tasks_in_process; + let mut pt_tasks = JoinSet::new(); + let pt_tasks_len = Arc::new(AtomicUsize::new(0)); + tokio::spawn({ + let pt_tasks_len = Arc::clone(&pt_tasks_len); + async move { + loop { + program_transformer_tasks_total_set(pt_tasks_len.load(Ordering::Relaxed)); + sleep(Duration::from_millis(100)).await; + } + } + }); + + // read and process messages in the loop let mut shutdown = create_shutdown()?; let result = loop { - tokio::select! { + pt_tasks_len.store(pt_tasks.len(), Ordering::Relaxed); + + let redis_messages_recv = if pt_tasks.len() == pt_max_tasks_in_process { + pending().boxed() + } else { + redis_messages.recv().boxed() + }; + let pt_tasks_next = if pt_tasks.is_empty() { + pending().boxed() + } else { + pt_tasks.join_next().boxed() + }; + + let msg = tokio::select! { result = &mut jh_metrics_xlen => match result { Ok(Ok(_)) => unreachable!(), Ok(Err(error)) => break Err(error), @@ -61,21 +111,94 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { } else { "UNKNOWN" }; - tracing::warn!("{signal} received, waiting spawned tasks..."); + warn!("{signal} received, waiting spawned tasks..."); break Ok(()); }, result = &mut redis_tasks_fut => break result, - msg = redis_messages.recv() => match msg { - Some(msg) => { - // TODO: process messages here - msg.ack()?; - } + msg = redis_messages_recv => match msg { + Some(msg) => msg, None => break Ok(()), + }, + result = pt_tasks_next => { + if let Some(result) = result { + result??; + } + continue; } }; + + pt_tasks.spawn({ + let pt_accounts = Arc::clone(&pt_accounts); + let pt_transactions = Arc::clone(&pt_transactions); + async move { + let result = match &msg.get_data() { + ProgramTransformerInfo::Account(account) => { + pt_accounts.handle_account_update(account).await + } + ProgramTransformerInfo::Transaction(transaction) => { + pt_transactions.handle_transaction(transaction).await + } + }; + + macro_rules! log_or_bail { + ($action:path, $msg:expr, $error:ident) => { + match msg.get_data() { + ProgramTransformerInfo::Account(account) => { + $action!("{} account {}: {:?}", $msg, account.pubkey, $error) + } + ProgramTransformerInfo::Transaction(transaction) => { + $action!( + "{} transaction {}: {:?}", + $msg, + transaction.signature, + $error + ) + } + } + }; + } + + match result { + Ok(()) => program_transformer_task_status_inc( + ProgramTransformerTaskStatusKind::Success, + ), + Err(ProgramTransformerError::NotImplemented) => { + program_transformer_task_status_inc( + ProgramTransformerTaskStatusKind::NotImplemented, + ) + } + Err(ProgramTransformerError::DeserializationError(error)) => { + program_transformer_task_status_inc( + ProgramTransformerTaskStatusKind::DeserializationError, + ); + log_or_bail!(warn, "failed to deserialize", error) + } + Err(ProgramTransformerError::ParsingError(error)) => { + program_transformer_task_status_inc( + ProgramTransformerTaskStatusKind::ParsingError, + ); + log_or_bail!(warn, "failed to parse", error) + } + Err(ProgramTransformerError::DatabaseError(error)) => { + log_or_bail!(anyhow::bail, "database error for", error) + } + Err(ProgramTransformerError::AssetIndexError(error)) => { + log_or_bail!(anyhow::bail, "indexing error for ", error) + } + Err(error) => { + log_or_bail!(anyhow::bail, "failed to handle", error) + } + } + + msg.ack() + } + }); }; redis_messages.shutdown(); + while let Some(result) = pt_tasks.join_next().await { + result??; + } if !redis_tasks_fut.is_terminated() { redis_tasks_fut.await?; } @@ -84,8 +207,14 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { result } -async fn run_program_transformers() -> anyhow::Result<()> { - // let pt_accounts = ProgramTransformer::new() - - todo!() +fn create_notifier() -> DownloadMetadataNotifier { + Box::new( + move |_info: DownloadMetadataInfo| -> BoxFuture< + 'static, + Result<(), Box>, + > { + // TODO + Box::pin(async move { Ok(()) }) + }, + ) } diff --git a/nft_ingester2/src/postgres.rs b/nft_ingester2/src/postgres.rs index 6f7bc3c0d..05e535b4d 100644 --- a/nft_ingester2/src/postgres.rs +++ b/nft_ingester2/src/postgres.rs @@ -7,22 +7,20 @@ use { postgres::{PgConnectOptions, PgPoolOptions}, PgPool, }, - std::sync::Arc, tokio::time::{sleep, Duration}, }; -pub async fn create_pool(config: ConfigIngesterPostgres) -> anyhow::Result> { +pub async fn create_pool(config: ConfigIngesterPostgres) -> anyhow::Result { let options: PgConnectOptions = config.url.parse()?; PgPoolOptions::new() .min_connections(config.min_connections.try_into()?) .max_connections(config.max_connections.try_into()?) .connect_with(options) .await - .map(Arc::new) .map_err(Into::into) } -pub async fn metrics_pgpool(pgpool: Arc) { +pub async fn metrics_pgpool(pgpool: PgPool) { loop { pgpool_connections_set(PgpoolConnectionsKind::Total, pgpool.size() as usize); pgpool_connections_set(PgpoolConnectionsKind::Idle, pgpool.num_idle()); diff --git a/nft_ingester2/src/prom.rs b/nft_ingester2/src/prom.rs index 1b048671e..884407760 100644 --- a/nft_ingester2/src/prom.rs +++ b/nft_ingester2/src/prom.rs @@ -5,7 +5,7 @@ use { service::{make_service_fn, service_fn}, Body, Request, Response, Server, StatusCode, }, - prometheus::{IntCounterVec, IntGaugeVec, Opts, Registry, TextEncoder}, + prometheus::{IntCounterVec, IntGauge, IntGaugeVec, Opts, Registry, TextEncoder}, std::{net::SocketAddr, sync::Once}, tracing::{error, info}, }; @@ -37,6 +37,15 @@ lazy_static::lazy_static! { Opts::new("pgpool_connections_total", "Total number of connections in Postgres Pool"), &["kind"] ).unwrap(); + + static ref PROGRAM_TRANSFORMER_TASKS_TOTAL: IntGauge = IntGauge::new( + "program_transformer_tasks_total", "Number of tasks spawned for program transform" + ).unwrap(); + + static ref PROGRAM_TRANSFORMER_TASK_STATUS: IntCounterVec = IntCounterVec::new( + Opts::new("program_transformer_task_status", "Status of processed messages"), + &["status"], + ).unwrap(); } pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { @@ -54,6 +63,8 @@ pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { register!(REDIS_XADD_STATUS); register!(REDIS_XACK_TOTAL); register!(PGPOOL_CONNECTIONS_TOTAL); + register!(PROGRAM_TRANSFORMER_TASKS_TOTAL); + register!(PROGRAM_TRANSFORMER_TASK_STATUS); VERSION .with_label_values(&[ @@ -137,3 +148,26 @@ pub fn pgpool_connections_set(kind: PgpoolConnectionsKind, size: usize) { }]) .set(size as i64) } + +pub fn program_transformer_tasks_total_set(size: usize) { + PROGRAM_TRANSFORMER_TASKS_TOTAL.set(size as i64) +} + +#[derive(Debug, Clone, Copy)] +pub enum ProgramTransformerTaskStatusKind { + Success, + NotImplemented, + DeserializationError, + ParsingError, +} + +pub fn program_transformer_task_status_inc(kind: ProgramTransformerTaskStatusKind) { + PROGRAM_TRANSFORMER_TASK_STATUS + .with_label_values(&[match kind { + ProgramTransformerTaskStatusKind::Success => "success", + ProgramTransformerTaskStatusKind::NotImplemented => "not_implemented", + ProgramTransformerTaskStatusKind::DeserializationError => "deserialization_error", + ProgramTransformerTaskStatusKind::ParsingError => "parsing_error", + }]) + .inc() +} diff --git a/nft_ingester2/src/redis.rs b/nft_ingester2/src/redis.rs index 554f02c6e..b823f4fee 100644 --- a/nft_ingester2/src/redis.rs +++ b/nft_ingester2/src/redis.rs @@ -3,7 +3,8 @@ use { config::{ConfigIngesterRedis, ConfigIngesterRedisStreamType}, prom::{redis_xack_inc, redis_xlen_set}, }, - futures::future::{BoxFuture, FutureExt}, + futures::future::{BoxFuture, Fuse, FutureExt}, + program_transformers::{AccountInfo, TransactionInfo}, redis::{ aio::MultiplexedConnection, streams::{ @@ -12,6 +13,7 @@ use { }, AsyncCommands, ErrorKind as RedisErrorKind, RedisResult, Value as RedisValue, }, + solana_sdk::{pubkey::Pubkey, signature::Signature}, std::{ collections::HashMap, convert::Infallible, @@ -26,6 +28,9 @@ use { time::{sleep, Duration, Instant}, }, yellowstone_grpc_proto::{ + convert_from::{ + create_message_instructions, create_meta_inner_instructions, create_pubkey_vec, + }, prelude::{SubscribeUpdateAccount, SubscribeUpdateTransaction}, prost::Message, }, @@ -90,17 +95,16 @@ struct RedisStreamInfo { xack_max_in_process: usize, } -#[allow(clippy::large_enum_variant)] #[derive(Debug)] -pub enum RedisStreamMessage { - Account(SubscribeUpdateAccount), - Transaction(SubscribeUpdateTransaction), +pub enum ProgramTransformerInfo { + Account(AccountInfo), + Transaction(TransactionInfo), } #[derive(Debug)] pub struct RedisStreamMessageInfo { id: String, - data: RedisStreamMessage, + data: ProgramTransformerInfo, ack_tx: mpsc::UnboundedSender, } @@ -110,14 +114,69 @@ impl RedisStreamMessageInfo { StreamId { id, map }: StreamId, ack_tx: mpsc::UnboundedSender, ) -> anyhow::Result { + let to_anyhow = |error: String| anyhow::anyhow!(error); + let data = match map.get(&stream.stream_data_key) { Some(RedisValue::Data(vec)) => match stream.stream_type { ConfigIngesterRedisStreamType::Account => { - RedisStreamMessage::Account(SubscribeUpdateAccount::decode(vec.as_ref())?) + let SubscribeUpdateAccount { account, slot, .. } = + Message::decode(vec.as_ref())?; + + let account = account.ok_or_else(|| { + anyhow::anyhow!("received invalid SubscribeUpdateAccount") + })?; + + ProgramTransformerInfo::Account(AccountInfo { + slot, + pubkey: Pubkey::try_from(account.pubkey.as_slice())?, + owner: Pubkey::try_from(account.owner.as_slice())?, + data: account.data, + }) + } + ConfigIngesterRedisStreamType::Transaction => { + let SubscribeUpdateTransaction { transaction, slot } = + Message::decode(vec.as_ref())?; + + let transaction = transaction.ok_or_else(|| { + anyhow::anyhow!("received invalid SubscribeUpdateTransaction") + })?; + let tx = transaction.transaction.ok_or_else(|| { + anyhow::anyhow!( + "received invalid transaction in SubscribeUpdateTransaction" + ) + })?; + let message = tx.message.ok_or_else(|| { + anyhow::anyhow!("received invalid message in SubscribeUpdateTransaction") + })?; + let meta = transaction.meta.ok_or_else(|| { + anyhow::anyhow!("received invalid meta in SubscribeUpdateTransaction") + })?; + + let mut account_keys = + create_pubkey_vec(message.account_keys).map_err(to_anyhow)?; + for pubkey in + create_pubkey_vec(meta.loaded_writable_addresses).map_err(to_anyhow)? + { + account_keys.push(pubkey); + } + for pubkey in + create_pubkey_vec(meta.loaded_readonly_addresses).map_err(to_anyhow)? + { + account_keys.push(pubkey); + } + + ProgramTransformerInfo::Transaction(TransactionInfo { + slot, + signature: Signature::try_from(transaction.signature.as_slice())?, + account_keys, + message_instructions: create_message_instructions(message.instructions) + .map_err(to_anyhow)?, + meta_inner_instructions: create_meta_inner_instructions( + meta.inner_instructions, + ) + .map_err(to_anyhow)?, + }) } - ConfigIngesterRedisStreamType::Transaction => RedisStreamMessage::Transaction( - SubscribeUpdateTransaction::decode(vec.as_ref())?, - ), }, Some(_) => anyhow::bail!( "invalid data (key: {:?}) from stream {:?}", @@ -133,6 +192,10 @@ impl RedisStreamMessageInfo { Ok(Self { id, data, ack_tx }) } + pub const fn get_data(&self) -> &ProgramTransformerInfo { + &self.data + } + pub fn ack(self) -> anyhow::Result<()> { self.ack_tx .send(self.id) @@ -150,7 +213,7 @@ impl RedisStream { pub async fn new( config: ConfigIngesterRedis, mut connection: MultiplexedConnection, - ) -> anyhow::Result<(Self, BoxFuture<'static, anyhow::Result<()>>)> { + ) -> anyhow::Result<(Self, Fuse>>)> { // create group with consumer per stream for stream in config.streams.iter() { xgroup_create( @@ -209,15 +272,14 @@ impl RedisStream { task.await??; } Ok::<(), anyhow::Error>(()) - } - .boxed(); + }; Ok(( Self { shutdown, messages_rx, }, - spawned_tasks, + spawned_tasks.boxed().fuse(), )) } From 53fa481445b2b2c33d8bc712b25efb3144298863 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Wed, 29 Nov 2023 22:10:42 -0500 Subject: [PATCH 17/21] add force shutdown with signals --- Cargo.lock | 1 + Cargo.toml | 1 + nft_ingester2/Cargo.toml | 1 + nft_ingester2/src/grpc.rs | 27 +++++++++++----------- nft_ingester2/src/ingester.rs | 43 ++++++++++++++++++++--------------- nft_ingester2/src/redis.rs | 14 +++++++----- nft_ingester2/src/util.rs | 15 +++++++----- 7 files changed, 59 insertions(+), 43 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index fd708440f..3f884075b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3727,6 +3727,7 @@ name = "nft_ingester2" version = "0.7.2" dependencies = [ "anyhow", + "async-stream", "atty", "cargo-lock", "clap 4.5.4", diff --git a/Cargo.toml b/Cargo.toml index 3cf0fcbfb..a666f375f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,6 +33,7 @@ anchor-client = "0.29.0" anchor-lang = "0.29.0" anyhow = "1.0.75" async-std = "1.0.0" +async-stream = "0.3.5" async-trait = "0.1.60" blockbuster = "2.2.1" atty = "0.2.14" diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml index 455f2902d..4ab4f7f80 100644 --- a/nft_ingester2/Cargo.toml +++ b/nft_ingester2/Cargo.toml @@ -7,6 +7,7 @@ publish = { workspace = true } [dependencies] anyhow = { workspace = true } +async-stream = { workspace = true } atty = { workspace = true } sqlx = { workspace = true, features = [ "macros", diff --git a/nft_ingester2/src/grpc.rs b/nft_ingester2/src/grpc.rs index aebb88b8a..01387c025 100644 --- a/nft_ingester2/src/grpc.rs +++ b/nft_ingester2/src/grpc.rs @@ -7,10 +7,10 @@ use { redis::{streams::StreamMaxlen, RedisResult, Value as RedisValue}, std::{sync::Arc, time::Duration}, tokio::{ - signal::unix::SignalKind, task::JoinSet, time::{sleep, Instant}, }, + tracing::warn, yellowstone_grpc_client::GeyserGrpcClient, yellowstone_grpc_proto::{prelude::subscribe_update::UpdateOneof, prost::Message}, }; @@ -59,15 +59,8 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { Ok(Err(error)) => break Err(error), Err(error) => break Err(error.into()), }, - signal = &mut shutdown => { - let signal = if signal == SignalKind::interrupt() { - "SIGINT" - } else if signal == SignalKind::terminate() { - "SIGTERM" - } else { - "UNKNOWN" - }; - tracing::warn!("{signal} received, waiting spawned tasks..."); + Some(signal) = shutdown.next() => { + warn!("{signal} received, waiting spawned tasks..."); break Ok(()); }, msg = stream.next() => { @@ -138,9 +131,17 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { } }; - while let Some(result) = tasks.join_next().await { - result??; - } + tokio::select! { + Some(signal) = shutdown.next() => { + anyhow::bail!("{signal} received, force shutdown..."); + } + result = async move { + while let Some(result) = tasks.join_next().await { + result??; + } + Ok::<(), anyhow::Error>(()) + } => result?, + }; result } diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 0d7d43478..479e5bddb 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -9,7 +9,10 @@ use { redis::{metrics_xlen, ProgramTransformerInfo, RedisStream}, util::create_shutdown, }, - futures::future::{pending, BoxFuture, FusedFuture, FutureExt}, + futures::{ + future::{pending, BoxFuture, FusedFuture, FutureExt}, + stream::StreamExt, + }, program_transformers::{ error::ProgramTransformerError, DownloadMetadataInfo, DownloadMetadataNotifier, ProgramTransformer, @@ -19,7 +22,6 @@ use { Arc, }, tokio::{ - signal::unix::SignalKind, task::JoinSet, time::{sleep, Duration}, }, @@ -103,14 +105,7 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { Ok(Err(error)) => break Err(error), Err(error) => break Err(error.into()), }, - signal = &mut shutdown => { - let signal = if signal == SignalKind::interrupt() { - "SIGINT" - } else if signal == SignalKind::terminate() { - "SIGTERM" - } else { - "UNKNOWN" - }; + Some(signal) = shutdown.next() => { warn!("{signal} received, waiting spawned tasks..."); break Ok(()); }, @@ -195,14 +190,26 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { }); }; - redis_messages.shutdown(); - while let Some(result) = pt_tasks.join_next().await { - result??; - } - if !redis_tasks_fut.is_terminated() { - redis_tasks_fut.await?; - } - pgpool.close().await; + tokio::select! { + Some(signal) = shutdown.next() => { + anyhow::bail!("{signal} received, force shutdown..."); + } + result = async move { + // shutdown `prefetch` channel (but not Receiver) + redis_messages.shutdown(); + // wait all `program_transformer` spawned tasks + while let Some(result) = pt_tasks.join_next().await { + result??; + } + // wait all `ack` spawned tasks + if !redis_tasks_fut.is_terminated() { + redis_tasks_fut.await?; + } + // shutdown database connection + pgpool.close().await; + Ok::<(), anyhow::Error>(()) + } => result?, + }; result } diff --git a/nft_ingester2/src/redis.rs b/nft_ingester2/src/redis.rs index b823f4fee..1baec8799 100644 --- a/nft_ingester2/src/redis.rs +++ b/nft_ingester2/src/redis.rs @@ -251,7 +251,7 @@ impl RedisStream { .collect::>(); // spawn xack tasks - let mut tasks = ack_tasks + let ack_jh_vec = ack_tasks .into_iter() .map(|(stream, ack_rx)| { let connection = connection.clone(); @@ -261,15 +261,16 @@ impl RedisStream { // spawn prefetch task let (messages_tx, messages_rx) = mpsc::channel(config.prefetch_queue_size); - tasks.push(tokio::spawn({ + let jh_prefetch = tokio::spawn({ let shutdown = Arc::clone(&shutdown); async move { Self::run_prefetch(config, streams, connection, messages_tx, shutdown).await } - })); + }); // merge spawned xack / prefetch tasks let spawned_tasks = async move { - for task in tasks.into_iter() { - task.await??; + jh_prefetch.await??; + for jh in ack_jh_vec.into_iter() { + jh.await??; } Ok::<(), anyhow::Error>(()) }; @@ -287,8 +288,9 @@ impl RedisStream { self.messages_rx.recv().await } - pub fn shutdown(self) { + pub fn shutdown(mut self) { self.shutdown.store(true, Ordering::Relaxed); + tokio::spawn(async move { while self.messages_rx.recv().await.is_some() {} }); } async fn run_prefetch( diff --git a/nft_ingester2/src/util.rs b/nft_ingester2/src/util.rs index 6de97e42f..0a7800a12 100644 --- a/nft_ingester2/src/util.rs +++ b/nft_ingester2/src/util.rs @@ -1,15 +1,18 @@ use { - futures::future::{BoxFuture, FutureExt}, + async_stream::stream, + futures::stream::{BoxStream, StreamExt}, tokio::signal::unix::{signal, SignalKind}, }; -pub fn create_shutdown() -> anyhow::Result> { +pub fn create_shutdown() -> anyhow::Result> { let mut sigint = signal(SignalKind::interrupt())?; let mut sigterm = signal(SignalKind::terminate())?; - Ok(async move { - tokio::select! { - _ = sigint.recv() => SignalKind::interrupt(), - _ = sigterm.recv() => SignalKind::terminate(), + Ok(stream! { + loop { + yield tokio::select! { + _ = sigint.recv() => "SIGINT", + _ = sigterm.recv() => "SIGTERM", + }; } } .boxed()) From 11b4151d3e7492b638f9a865e3a1645d24461279 Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Thu, 30 Nov 2023 21:20:38 -0500 Subject: [PATCH 18/21] insert download metadata tasks --- Cargo.lock | 14 +++ metaplex-rpc-proxy/Cargo.toml | 2 + nft_ingester/src/transaction_notifications.rs | 2 +- nft_ingester2/Cargo.toml | 5 ++ nft_ingester2/config-run.yml | 6 +- nft_ingester2/src/config.rs | 29 ++++++- nft_ingester2/src/ingester.rs | 85 ++++++++++++++----- nft_ingester2/src/main.rs | 1 + nft_ingester2/src/prom.rs | 11 ++- program_transformers/Cargo.toml | 1 + program_transformers/src/lib.rs | 3 +- 11 files changed, 132 insertions(+), 27 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3f884075b..a8f8fa573 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3537,6 +3537,8 @@ dependencies = [ "log", "proxy-wasm", "regex", + "wasi 0.7.0", + "wasm-bindgen", ] [[package]] @@ -3730,7 +3732,9 @@ dependencies = [ "async-stream", "atty", "cargo-lock", + "chrono", "clap 4.5.4", + "digital_asset_types", "futures", "git-version", "hyper", @@ -3742,7 +3746,10 @@ dependencies = [ "program_transformers", "prometheus", "redis 0.25.3", + "rust-crypto", + "sea-orm", "serde", + "serde_json", "serde_yaml", "solana-sdk", "sqlx", @@ -4633,6 +4640,7 @@ dependencies = [ "mpl-bubblegum", "num-traits", "sea-orm", + "serde", "serde_json", "solana-sdk", "solana-transaction-status", @@ -8166,6 +8174,12 @@ dependencies = [ "try-lock", ] +[[package]] +name = "wasi" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b89c3ce4ce14bdc6fb6beaf9ec7928ca331de5df7e5ea278375642a2f478570d" + [[package]] name = "wasi" version = "0.9.0+wasi-snapshot-preview1" diff --git a/metaplex-rpc-proxy/Cargo.toml b/metaplex-rpc-proxy/Cargo.toml index 06b801543..2e69785dd 100644 --- a/metaplex-rpc-proxy/Cargo.toml +++ b/metaplex-rpc-proxy/Cargo.toml @@ -13,6 +13,8 @@ lazy_static = { workspace = true } log = { workspace = true } proxy-wasm = { workspace = true } regex = { workspace = true } +wasi = { workspace = true } +wasm-bindgen = { workspace = true } [lints] workspace = true diff --git a/nft_ingester/src/transaction_notifications.rs b/nft_ingester/src/transaction_notifications.rs index 5335de6dc..df005bc56 100644 --- a/nft_ingester/src/transaction_notifications.rs +++ b/nft_ingester/src/transaction_notifications.rs @@ -10,7 +10,7 @@ use { log::{debug, error}, plerkle_messenger::{ConsumptionType, Messenger, MessengerConfig, RecvData}, plerkle_serialization::root_as_transaction_info, - program_transformers::{error::ProgramTransformerResult, ProgramTransformer, TransactionInfo}, + program_transformers::ProgramTransformer, sqlx::{Pool, Postgres}, std::sync::Arc, tokio::{ diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml index 4ab4f7f80..bf3f590ec 100644 --- a/nft_ingester2/Cargo.toml +++ b/nft_ingester2/Cargo.toml @@ -17,7 +17,9 @@ sqlx = { workspace = true, features = [ "offline", "json", ] } +chrono = { workspace = true } clap = { workspace = true, features = ["cargo", "derive"] } +digital_asset_types = { workspace = true } futures = { workspace = true } hyper = { workspace = true, features = ["server"] } json5 = { workspace = true } @@ -28,7 +30,10 @@ opentelemetry_sdk = { workspace = true, features = ["trace"] } program_transformers = { workspace = true } prometheus = { workspace = true } redis = { workspace = true, features = ["tokio-comp", "tokio-native-tls-comp"] } +rust-crypto = { workspace = true } +sea-orm = { workspace = true, features = ["sqlx-postgres"] } serde = { workspace = true } +serde_json = { workspace = true } serde_yaml = { workspace = true } solana-sdk = { workspace = true } # only prom rn tokio = { workspace = true, features = [ diff --git a/nft_ingester2/config-run.yml b/nft_ingester2/config-run.yml index 19a1b3f84..3af3ad2e7 100644 --- a/nft_ingester2/config-run.yml +++ b/nft_ingester2/config-run.yml @@ -20,7 +20,9 @@ redis: postgres: url: postgres://solana:solana@localhost/solana min_connections: 10 - max_connections: 25 + max_connections: 50 # `max_connection` should be bigger than `program_transformer.max_tasks_in_process` otherwise unresolved lock is possible program_transformer: transactions_cl_audits: false - max_tasks_in_process: 100 + max_tasks_in_process: 40 +download_metadata_handler: + max_attempts: 3 diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs index 003985f27..d01bfeeaa 100644 --- a/nft_ingester2/src/config.rs +++ b/nft_ingester2/src/config.rs @@ -3,6 +3,7 @@ use { serde::{de, Deserialize}, std::{net::SocketAddr, path::Path, time::Duration}, tokio::fs, + tracing::warn, yellowstone_grpc_tools::config::{ deserialize_usize_str, ConfigGrpcRequestAccounts, ConfigGrpcRequestCommitment, ConfigGrpcRequestTransactions, @@ -154,6 +155,15 @@ pub struct ConfigIngester { pub redis: ConfigIngesterRedis, pub postgres: ConfigIngesterPostgres, pub program_transformer: ConfigIngesterProgramTransformer, + pub download_metadata_handler: ConfigDownloadMetadataHandler, +} + +impl ConfigIngester { + pub fn check(&self) { + if self.postgres.max_connections < self.program_transformer.max_tasks_in_process { + warn!("`postgres.max_connections` should be bigger than `program_transformer.max_tasks_in_process` otherwise unresolved lock is possible"); + } + } } #[derive(Debug, Deserialize)] @@ -305,7 +315,7 @@ impl ConfigIngesterPostgres { } pub const fn default_max_connections() -> usize { - 25 + 50 } } @@ -326,6 +336,21 @@ impl ConfigIngesterProgramTransformer { } pub const fn default_max_tasks_in_process() -> usize { - 100 + 40 + } +} + +#[derive(Debug, Clone, Copy, Deserialize)] +pub struct ConfigDownloadMetadataHandler { + #[serde( + default = "ConfigDownloadMetadataHandler::default_max_attempts", + deserialize_with = "deserialize_usize_str" + )] + pub max_attempts: usize, +} + +impl ConfigDownloadMetadataHandler { + pub const fn default_max_attempts() -> usize { + 3 } } diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 479e5bddb..22f4311c2 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -1,14 +1,17 @@ use { crate::{ - config::ConfigIngester, + config::{ConfigDownloadMetadataHandler, ConfigIngester}, postgres::{create_pool as pg_create_pool, metrics_pgpool}, prom::{ - program_transformer_task_status_inc, program_transformer_tasks_total_set, - ProgramTransformerTaskStatusKind, + download_metadata_inserted_total_inc, program_transformer_task_status_inc, + program_transformer_tasks_total_set, ProgramTransformerTaskStatusKind, }, redis::{metrics_xlen, ProgramTransformerInfo, RedisStream}, util::create_shutdown, }, + chrono::Utc, + crypto::{digest::Digest, sha2::Sha256}, + digital_asset_types::dao::{sea_orm_active_enums::TaskStatus, tasks}, futures::{ future::{pending, BoxFuture, FusedFuture, FutureExt}, stream::StreamExt, @@ -17,9 +20,18 @@ use { error::ProgramTransformerError, DownloadMetadataInfo, DownloadMetadataNotifier, ProgramTransformer, }, - std::sync::{ - atomic::{AtomicUsize, Ordering}, - Arc, + sea_orm::{ + entity::{ActiveModelTrait, ActiveValue}, + error::{DbErr, RuntimeErr}, + SqlxPostgresConnector, + }, + sqlx::{Error as SqlxError, PgPool}, + std::{ + borrow::Cow, + sync::{ + atomic::{AtomicUsize, Ordering}, + Arc, + }, }, tokio::{ task::JoinSet, @@ -29,8 +41,6 @@ use { }; pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { - println!("{:#?}", config); - // connect to Redis let client = redis::Client::open(config.redis.url.clone())?; let connection = client.get_multiplexed_tokio_connection().await?; @@ -62,12 +72,12 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { // program transforms related let pt_accounts = Arc::new(ProgramTransformer::new( pgpool.clone(), - create_notifier(), + create_download_metadata_notifier(pgpool.clone(), config.download_metadata_handler)?, false, )); let pt_transactions = Arc::new(ProgramTransformer::new( pgpool.clone(), - create_notifier(), + create_download_metadata_notifier(pgpool.clone(), config.download_metadata_handler)?, config.program_transformer.transactions_cl_audits, )); let pt_max_tasks_in_process = config.program_transformer.max_tasks_in_process; @@ -214,14 +224,49 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { result } -fn create_notifier() -> DownloadMetadataNotifier { - Box::new( - move |_info: DownloadMetadataInfo| -> BoxFuture< - 'static, - Result<(), Box>, - > { - // TODO - Box::pin(async move { Ok(()) }) - }, - ) +fn create_download_metadata_notifier( + pgpool: PgPool, + config: ConfigDownloadMetadataHandler, +) -> anyhow::Result { + let max_attempts = config.max_attempts.try_into()?; + Ok(Box::new(move |info: DownloadMetadataInfo| -> BoxFuture< + 'static, + Result<(), Box>, + > { + let pgpool = pgpool.clone(); + Box::pin(async move { + const NAME: &str = "DownloadMetadata"; + + let data = serde_json::to_value(info)?; + + let mut hasher = Sha256::new(); + hasher.input(NAME.as_bytes()); + hasher.input(serde_json::to_vec(&data)?.as_slice()); + let hash = hasher.result_str(); + + let model = tasks::ActiveModel { + id: ActiveValue::Set(hash), + task_type: ActiveValue::Set(NAME.to_owned()), + data: ActiveValue::Set(data), + status: ActiveValue::Set(TaskStatus::Pending), + created_at: ActiveValue::Set(Utc::now().naive_utc()), + locked_until: ActiveValue::Set(None), + locked_by: ActiveValue::Set(None), + max_attempts: ActiveValue::Set(max_attempts), + attempts: ActiveValue::Set(0), + duration: ActiveValue::Set(None), + errors: ActiveValue::Set(None), + }; + let conn = SqlxPostgresConnector::from_sqlx_postgres_pool(pgpool); + + match model.insert(&conn).await.map(|_mode| ()) { + // skip unique_violation error + Err(DbErr::Query(RuntimeErr::SqlxError(SqlxError::Database(dberr)))) if dberr.code() == Some(Cow::Borrowed("23505")) => {}, + value => value?, + }; + download_metadata_inserted_total_inc(); + + Ok(()) + }) + })) } diff --git a/nft_ingester2/src/main.rs b/nft_ingester2/src/main.rs index 0bd1f9b8d..7622b8aec 100644 --- a/nft_ingester2/src/main.rs +++ b/nft_ingester2/src/main.rs @@ -70,6 +70,7 @@ async fn main() -> anyhow::Result<()> { let config = config_load::(&args.config) .await .with_context(|| format!("failed to parse config from: {}", args.config))?; + config.check(); ingester::run(config).await } } diff --git a/nft_ingester2/src/prom.rs b/nft_ingester2/src/prom.rs index 884407760..e81de4255 100644 --- a/nft_ingester2/src/prom.rs +++ b/nft_ingester2/src/prom.rs @@ -5,7 +5,7 @@ use { service::{make_service_fn, service_fn}, Body, Request, Response, Server, StatusCode, }, - prometheus::{IntCounterVec, IntGauge, IntGaugeVec, Opts, Registry, TextEncoder}, + prometheus::{IntCounter, IntCounterVec, IntGauge, IntGaugeVec, Opts, Registry, TextEncoder}, std::{net::SocketAddr, sync::Once}, tracing::{error, info}, }; @@ -46,6 +46,10 @@ lazy_static::lazy_static! { Opts::new("program_transformer_task_status", "Status of processed messages"), &["status"], ).unwrap(); + + static ref DOWNLOAD_METADATA_INSERTED_TOTAL: IntCounter = IntCounter::new( + "download_metadata_inserted_total", "Total number of inserted tasks for download metadata" + ).unwrap(); } pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { @@ -65,6 +69,7 @@ pub fn run_server(address: SocketAddr) -> anyhow::Result<()> { register!(PGPOOL_CONNECTIONS_TOTAL); register!(PROGRAM_TRANSFORMER_TASKS_TOTAL); register!(PROGRAM_TRANSFORMER_TASK_STATUS); + register!(DOWNLOAD_METADATA_INSERTED_TOTAL); VERSION .with_label_values(&[ @@ -171,3 +176,7 @@ pub fn program_transformer_task_status_inc(kind: ProgramTransformerTaskStatusKin }]) .inc() } + +pub fn download_metadata_inserted_total_inc() { + DOWNLOAD_METADATA_INSERTED_TOTAL.inc() +} diff --git a/program_transformers/Cargo.toml b/program_transformers/Cargo.toml index 08f784632..aa96212e7 100644 --- a/program_transformers/Cargo.toml +++ b/program_transformers/Cargo.toml @@ -19,6 +19,7 @@ heck = { workspace = true } mpl-bubblegum = { workspace = true } num-traits = { workspace = true } sea-orm = { workspace = true } +serde = { workspace = true } serde_json = { workspace = true } solana-sdk = { workspace = true } solana-transaction-status = { workspace = true } diff --git a/program_transformers/src/lib.rs b/program_transformers/src/lib.rs index edde20ca3..db52e55d4 100644 --- a/program_transformers/src/lib.rs +++ b/program_transformers/src/lib.rs @@ -20,6 +20,7 @@ use { entity::EntityTrait, query::Select, ConnectionTrait, DatabaseConnection, DbErr, SqlxPostgresConnector, TransactionTrait, }, + serde::Serialize, solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey, signature::Signature}, solana_transaction_status::InnerInstructions, sqlx::PgPool, @@ -52,7 +53,7 @@ pub struct TransactionInfo { pub meta_inner_instructions: Vec, } -#[derive(Debug, Clone, PartialEq, Eq)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] pub struct DownloadMetadataInfo { asset_data_id: Vec, uri: String, From 8fca2c22bf27fd2449ddd76af790b22cfff2744c Mon Sep 17 00:00:00 2001 From: Kirill Fomichev Date: Fri, 1 Dec 2023 22:34:46 -0500 Subject: [PATCH 19/21] download-metadata subtask --- Cargo.lock | 1 + nft_ingester2/Cargo.toml | 1 + nft_ingester2/config-download-metadata.yml | 12 + .../{config-run.yml => config-ingester.yml} | 2 +- nft_ingester2/src/config.rs | 67 ++++- nft_ingester2/src/download_metadata.rs | 236 ++++++++++++++++++ nft_ingester2/src/ingester.rs | 25 +- nft_ingester2/src/main.rs | 19 +- nft_ingester2/src/tracing.rs | 3 +- program_transformers/src/lib.rs | 4 +- 10 files changed, 345 insertions(+), 25 deletions(-) create mode 100644 nft_ingester2/config-download-metadata.yml rename nft_ingester2/{config-run.yml => config-ingester.yml} (97%) create mode 100644 nft_ingester2/src/download_metadata.rs diff --git a/Cargo.lock b/Cargo.lock index a8f8fa573..347dbf5c5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3746,6 +3746,7 @@ dependencies = [ "program_transformers", "prometheus", "redis 0.25.3", + "reqwest", "rust-crypto", "sea-orm", "serde", diff --git a/nft_ingester2/Cargo.toml b/nft_ingester2/Cargo.toml index bf3f590ec..51afb7b09 100644 --- a/nft_ingester2/Cargo.toml +++ b/nft_ingester2/Cargo.toml @@ -30,6 +30,7 @@ opentelemetry_sdk = { workspace = true, features = ["trace"] } program_transformers = { workspace = true } prometheus = { workspace = true } redis = { workspace = true, features = ["tokio-comp", "tokio-native-tls-comp"] } +reqwest = { workspace = true } rust-crypto = { workspace = true } sea-orm = { workspace = true, features = ["sqlx-postgres"] } serde = { workspace = true } diff --git a/nft_ingester2/config-download-metadata.yml b/nft_ingester2/config-download-metadata.yml new file mode 100644 index 000000000..c42307be4 --- /dev/null +++ b/nft_ingester2/config-download-metadata.yml @@ -0,0 +1,12 @@ +# Important: only ONE `download-metadata` instance is supported right now! +prometheus: 127.0.0.1:8875 +postgres: + url: postgres://solana:solana@localhost/solana + min_connections: 10 + max_connections: 50 +download_metadata: + max_in_process: 50 # maximum tasks in process (downloading metadata) + prefetch_queue_size: 100 + limit_to_fetch: 200 # maximum number of tasks fetched from database + wait_tasks_max_idle_ms: 100 # if we do not have pending tasks, wait max ms + download_timeout_ms: 5_000 diff --git a/nft_ingester2/config-run.yml b/nft_ingester2/config-ingester.yml similarity index 97% rename from nft_ingester2/config-run.yml rename to nft_ingester2/config-ingester.yml index 3af3ad2e7..bbb377a81 100644 --- a/nft_ingester2/config-run.yml +++ b/nft_ingester2/config-ingester.yml @@ -24,5 +24,5 @@ postgres: program_transformer: transactions_cl_audits: false max_tasks_in_process: 40 -download_metadata_handler: +download_metadata: max_attempts: 3 diff --git a/nft_ingester2/src/config.rs b/nft_ingester2/src/config.rs index d01bfeeaa..c3c45531e 100644 --- a/nft_ingester2/src/config.rs +++ b/nft_ingester2/src/config.rs @@ -155,7 +155,7 @@ pub struct ConfigIngester { pub redis: ConfigIngesterRedis, pub postgres: ConfigIngesterPostgres, pub program_transformer: ConfigIngesterProgramTransformer, - pub download_metadata_handler: ConfigDownloadMetadataHandler, + pub download_metadata: ConfigIngesterDownloadMetadata, } impl ConfigIngester { @@ -341,16 +341,75 @@ impl ConfigIngesterProgramTransformer { } #[derive(Debug, Clone, Copy, Deserialize)] -pub struct ConfigDownloadMetadataHandler { +pub struct ConfigIngesterDownloadMetadata { #[serde( - default = "ConfigDownloadMetadataHandler::default_max_attempts", + default = "ConfigIngesterDownloadMetadata::default_max_attempts", deserialize_with = "deserialize_usize_str" )] pub max_attempts: usize, } -impl ConfigDownloadMetadataHandler { +impl ConfigIngesterDownloadMetadata { pub const fn default_max_attempts() -> usize { 3 } } + +#[derive(Debug, Deserialize)] +pub struct ConfigDownloadMetadata { + pub postgres: ConfigIngesterPostgres, + pub download_metadata: ConfigDownloadMetadataOpts, +} + +#[derive(Debug, Clone, Copy, Deserialize)] +pub struct ConfigDownloadMetadataOpts { + #[serde( + default = "ConfigDownloadMetadataOpts::default_max_in_process", + deserialize_with = "deserialize_usize_str" + )] + pub max_in_process: usize, + #[serde( + default = "ConfigDownloadMetadataOpts::default_prefetch_queue_size", + deserialize_with = "deserialize_usize_str" + )] + pub prefetch_queue_size: usize, + #[serde( + default = "ConfigDownloadMetadataOpts::default_limit_to_fetch", + deserialize_with = "deserialize_usize_str" + )] + pub limit_to_fetch: usize, + #[serde( + default = "ConfigDownloadMetadataOpts::default_wait_tasks_max_idle", + deserialize_with = "deserialize_duration_str", + rename = "wait_tasks_max_idle_ms" + )] + pub wait_tasks_max_idle: Duration, + #[serde( + default = "ConfigDownloadMetadataOpts::default_download_timeout", + deserialize_with = "deserialize_duration_str", + rename = "download_timeout_ms" + )] + pub download_timeout: Duration, +} + +impl ConfigDownloadMetadataOpts { + pub const fn default_max_in_process() -> usize { + 50 + } + + pub const fn default_prefetch_queue_size() -> usize { + 100 + } + + pub const fn default_limit_to_fetch() -> usize { + 200 + } + + pub const fn default_wait_tasks_max_idle() -> Duration { + Duration::from_millis(100) + } + + pub const fn default_download_timeout() -> Duration { + Duration::from_millis(5_000) + } +} diff --git a/nft_ingester2/src/download_metadata.rs b/nft_ingester2/src/download_metadata.rs new file mode 100644 index 000000000..4392710b2 --- /dev/null +++ b/nft_ingester2/src/download_metadata.rs @@ -0,0 +1,236 @@ +use { + crate::{ + config::{ConfigDownloadMetadata, ConfigDownloadMetadataOpts}, + postgres::{create_pool as pg_create_pool, metrics_pgpool}, + util::create_shutdown, + }, + digital_asset_types::dao::{asset_data, sea_orm_active_enums::TaskStatus, tasks}, + futures::{ + future::{pending, FutureExt}, + stream::StreamExt, + }, + program_transformers::DownloadMetadataInfo, + reqwest::{ClientBuilder, StatusCode}, + sea_orm::{ + entity::{ActiveValue, ColumnTrait, EntityTrait}, + query::{Condition, Order, QueryFilter, QueryOrder, QuerySelect}, + sea_query::expr::Expr, + SqlxPostgresConnector, TransactionTrait, + }, + sqlx::PgPool, + std::{sync::Arc, time::Duration}, + tokio::{ + sync::{mpsc, Notify}, + task::JoinSet, + time::sleep, + }, + tracing::{info, warn}, +}; + +pub const TASK_TYPE: &str = "DownloadMetadata"; + +pub async fn run(config: ConfigDownloadMetadata) -> anyhow::Result<()> { + let mut shutdown = create_shutdown()?; + + // open connection to postgres + let pool = pg_create_pool(config.postgres).await?; + tokio::spawn({ + let pool = pool.clone(); + async move { metrics_pgpool(pool).await } + }); + + // reset previously runned tasks + tokio::select! { + result = reset_pending_tasks(pool.clone()) => { + let updated = result?; + info!("Reset {updated} tasks to Pending status"); + }, + Some(signal) = shutdown.next() => { + warn!("{signal} received, waiting spawned tasks..."); + return Ok(()) + }, + } + + // prefetch queue + let (tasks_tx, mut tasks_rx) = mpsc::channel(config.download_metadata.prefetch_queue_size); + let prefetch_shutdown = Arc::new(Notify::new()); + let prefetch_jh = { + let pool = pool.clone(); + let download_metadata = config.download_metadata; + let shutdown = Arc::clone(&prefetch_shutdown); + async move { + tokio::select! { + result = get_pending_tasks(pool, tasks_tx, download_metadata) => result, + _ = shutdown.notified() => Ok(()) + } + } + }; + tokio::pin!(prefetch_jh); + + // process tasks + let mut tasks = JoinSet::new(); + loop { + let pending_task_fut = if tasks.len() >= config.download_metadata.max_in_process { + pending().boxed() + } else { + tasks_rx.recv().boxed() + }; + + let tasks_fut = if tasks.is_empty() { + pending().boxed() + } else { + tasks.join_next().boxed() + }; + + tokio::select! { + Some(signal) = shutdown.next() => { + warn!("{signal} received, waiting spawned tasks..."); + break Ok(()); + }, + result = &mut prefetch_jh => break result, + Some(result) = tasks_fut => { + result??; + }, + Some(pending_task) = pending_task_fut => { + tasks.spawn(execute_task(pool.clone(), pending_task, config.download_metadata.download_timeout)); + } + }; + }?; + + tokio::select! { + Some(signal) = shutdown.next() => { + anyhow::bail!("{signal} received, force shutdown..."); + } + result = async move { + // shutdown `prefetch` channel + prefetch_shutdown.notify_one(); + // wait all spawned tasks + while let Some(result) = tasks.join_next().await { + result??; + } + // shutdown database connection + pool.close().await; + Ok::<(), anyhow::Error>(()) + } => result, + } +} + +// On startup reset tasks status +async fn reset_pending_tasks(pool: PgPool) -> anyhow::Result { + let conn = SqlxPostgresConnector::from_sqlx_postgres_pool(pool); + tasks::Entity::update_many() + .set(tasks::ActiveModel { + status: ActiveValue::Set(TaskStatus::Pending), + ..Default::default() + }) + .filter( + Condition::all() + .add(tasks::Column::Status.eq(TaskStatus::Running)) + .add(tasks::Column::TaskType.eq(TASK_TYPE)), + ) + .exec(&conn) + .await + .map(|result| result.rows_affected) + .map_err(Into::into) +} + +// Select Pending tasks, update status to Running and send to prefetch queue +async fn get_pending_tasks( + pool: PgPool, + tasks_tx: mpsc::Sender, + config: ConfigDownloadMetadataOpts, +) -> anyhow::Result<()> { + let conn = SqlxPostgresConnector::from_sqlx_postgres_pool(pool); + loop { + let pending_tasks = tasks::Entity::find() + .filter( + Condition::all() + .add(tasks::Column::Status.eq(TaskStatus::Pending)) + .add( + Expr::col(tasks::Column::Attempts) + .less_or_equal(Expr::col(tasks::Column::MaxAttempts)), + ), + ) + .order_by(tasks::Column::Attempts, Order::Asc) + .order_by(tasks::Column::CreatedAt, Order::Desc) + .limit(config.limit_to_fetch as u64) + .all(&conn) + .await?; + + if pending_tasks.is_empty() { + sleep(config.wait_tasks_max_idle).await; + } else { + tasks::Entity::update_many() + .set(tasks::ActiveModel { + status: ActiveValue::Set(TaskStatus::Running), + ..Default::default() + }) + .filter(tasks::Column::Id.is_in(pending_tasks.iter().map(|v| v.id.clone()))) + .exec(&conn) + .await?; + + for task in pending_tasks { + tasks_tx + .send(task) + .await + .map_err(|_error| anyhow::anyhow!("failed to send task to prefetch queue"))?; + } + } + } +} + +// Try to download metadata and remove task with asset_data update or update tasks to Pending/Failed +async fn execute_task(pool: PgPool, task: tasks::Model, timeout: Duration) -> anyhow::Result<()> { + let conn = SqlxPostgresConnector::from_sqlx_postgres_pool(pool); + match download_metadata(task.data, timeout).await { + Ok((asset_data_id, metadata)) => { + // Remove task and set metadata in transacstion + let txn = conn.begin().await?; + tasks::Entity::delete_by_id(task.id).exec(&txn).await?; + asset_data::Entity::update(asset_data::ActiveModel { + id: ActiveValue::Unchanged(asset_data_id), + metadata: ActiveValue::Set(metadata), + reindex: ActiveValue::Set(Some(false)), + ..Default::default() + }) + .exec(&txn) + .await?; + txn.commit().await?; + } + Err(error) => { + let status = if task.attempts + 1 == task.max_attempts { + TaskStatus::Failed + } else { + TaskStatus::Pending + }; + tasks::Entity::update(tasks::ActiveModel { + id: ActiveValue::Unchanged(task.id), + status: ActiveValue::Set(status), + attempts: ActiveValue::Set(task.attempts + 1), + errors: ActiveValue::Set(Some(error.to_string())), + ..Default::default() + }) + .exec(&conn) + .await?; + } + } + Ok(()) +} + +async fn download_metadata( + data: serde_json::Value, + timeout: Duration, +) -> anyhow::Result<(Vec, serde_json::Value)> { + let (id, uri) = serde_json::from_value::(data)?.into_inner(); + + // Need to check for malicious sites ? + let client = ClientBuilder::new().timeout(timeout).build()?; + let response = client.get(uri).send().await?; + + anyhow::ensure!( + response.status() == StatusCode::OK, + "HttpError status_code: {}", + response.status().as_str() + ); + Ok((id, response.json().await?)) +} diff --git a/nft_ingester2/src/ingester.rs b/nft_ingester2/src/ingester.rs index 22f4311c2..82cdc3cb5 100644 --- a/nft_ingester2/src/ingester.rs +++ b/nft_ingester2/src/ingester.rs @@ -1,6 +1,7 @@ use { crate::{ - config::{ConfigDownloadMetadataHandler, ConfigIngester}, + config::{ConfigIngester, ConfigIngesterDownloadMetadata}, + download_metadata::TASK_TYPE, postgres::{create_pool as pg_create_pool, metrics_pgpool}, prom::{ download_metadata_inserted_total_inc, program_transformer_task_status_inc, @@ -72,12 +73,12 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { // program transforms related let pt_accounts = Arc::new(ProgramTransformer::new( pgpool.clone(), - create_download_metadata_notifier(pgpool.clone(), config.download_metadata_handler)?, + create_download_metadata_notifier(pgpool.clone(), config.download_metadata)?, false, )); let pt_transactions = Arc::new(ProgramTransformer::new( pgpool.clone(), - create_download_metadata_notifier(pgpool.clone(), config.download_metadata_handler)?, + create_download_metadata_notifier(pgpool.clone(), config.download_metadata)?, config.program_transformer.transactions_cl_audits, )); let pt_max_tasks_in_process = config.program_transformer.max_tasks_in_process; @@ -95,7 +96,7 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { // read and process messages in the loop let mut shutdown = create_shutdown()?; - let result = loop { + loop { pt_tasks_len.store(pt_tasks.len(), Ordering::Relaxed); let redis_messages_recv = if pt_tasks.len() == pt_max_tasks_in_process { @@ -198,7 +199,7 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { msg.ack() } }); - }; + }?; tokio::select! { Some(signal) = shutdown.next() => { @@ -218,15 +219,13 @@ pub async fn run(config: ConfigIngester) -> anyhow::Result<()> { // shutdown database connection pgpool.close().await; Ok::<(), anyhow::Error>(()) - } => result?, - }; - - result + } => result, + } } fn create_download_metadata_notifier( pgpool: PgPool, - config: ConfigDownloadMetadataHandler, + config: ConfigIngesterDownloadMetadata, ) -> anyhow::Result { let max_attempts = config.max_attempts.try_into()?; Ok(Box::new(move |info: DownloadMetadataInfo| -> BoxFuture< @@ -235,18 +234,16 @@ fn create_download_metadata_notifier( > { let pgpool = pgpool.clone(); Box::pin(async move { - const NAME: &str = "DownloadMetadata"; - let data = serde_json::to_value(info)?; let mut hasher = Sha256::new(); - hasher.input(NAME.as_bytes()); + hasher.input(TASK_TYPE.as_bytes()); hasher.input(serde_json::to_vec(&data)?.as_slice()); let hash = hasher.result_str(); let model = tasks::ActiveModel { id: ActiveValue::Set(hash), - task_type: ActiveValue::Set(NAME.to_owned()), + task_type: ActiveValue::Set(TASK_TYPE.to_owned()), data: ActiveValue::Set(data), status: ActiveValue::Set(TaskStatus::Pending), created_at: ActiveValue::Set(Utc::now().naive_utc()), diff --git a/nft_ingester2/src/main.rs b/nft_ingester2/src/main.rs index 7622b8aec..9ca97d111 100644 --- a/nft_ingester2/src/main.rs +++ b/nft_ingester2/src/main.rs @@ -1,6 +1,9 @@ use { crate::{ - config::{load as config_load, ConfigGrpc, ConfigIngester, ConfigPrometheus}, + config::{ + load as config_load, ConfigDownloadMetadata, ConfigGrpc, ConfigIngester, + ConfigPrometheus, + }, prom::run_server as prometheus_run_server, tracing::init as tracing_init, }, @@ -10,6 +13,7 @@ use { }; mod config; +mod download_metadata; mod grpc; mod ingester; mod postgres; @@ -40,8 +44,11 @@ enum ArgsAction { #[command(name = "grpc2redis")] Grpc, /// Run ingester process (process events from Redis) - #[command(name = "run")] + #[command(name = "ingester")] Ingester, + /// Run metadata downloader + #[command(name = "download-metadata")] + DownloadMetadata, } #[tokio::main] @@ -58,7 +65,7 @@ async fn main() -> anyhow::Result<()> { prometheus_run_server(address)?; } - // Run grpc / ingester + // Run grpc / ingester / download-metadata match args.action { ArgsAction::Grpc => { let config = config_load::(&args.config) @@ -73,5 +80,11 @@ async fn main() -> anyhow::Result<()> { config.check(); ingester::run(config).await } + ArgsAction::DownloadMetadata => { + let config = config_load::(&args.config) + .await + .with_context(|| format!("failed to parse config from: {}", args.config))?; + download_metadata::run(config).await + } } } diff --git a/nft_ingester2/src/tracing.rs b/nft_ingester2/src/tracing.rs index 36ba4db56..2d50f785c 100644 --- a/nft_ingester2/src/tracing.rs +++ b/nft_ingester2/src/tracing.rs @@ -12,7 +12,8 @@ pub fn init() -> anyhow::Result<()> { .install_batch(opentelemetry_sdk::runtime::Tokio)?; let jeager_layer = tracing_opentelemetry::layer().with_tracer(open_tracer); - let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")); + let env_filter = EnvFilter::builder() + .parse(env::var(EnvFilter::DEFAULT_ENV).unwrap_or_else(|_| "info,sqlx=warn".to_owned()))?; let is_atty = atty::is(atty::Stream::Stdout) && atty::is(atty::Stream::Stderr); let io_layer = tracing_subscriber::fmt::layer().with_ansi(is_atty); diff --git a/program_transformers/src/lib.rs b/program_transformers/src/lib.rs index db52e55d4..6b6259d01 100644 --- a/program_transformers/src/lib.rs +++ b/program_transformers/src/lib.rs @@ -20,7 +20,7 @@ use { entity::EntityTrait, query::Select, ConnectionTrait, DatabaseConnection, DbErr, SqlxPostgresConnector, TransactionTrait, }, - serde::Serialize, + serde::{Deserialize, Serialize}, solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey, signature::Signature}, solana_transaction_status::InnerInstructions, sqlx::PgPool, @@ -53,7 +53,7 @@ pub struct TransactionInfo { pub meta_inner_instructions: Vec, } -#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] pub struct DownloadMetadataInfo { asset_data_id: Vec, uri: String, From fcc18d694bb6ec442f3de9933e26236758f59d22 Mon Sep 17 00:00:00 2001 From: Kyle Espinola Date: Wed, 10 Apr 2024 19:32:36 +0200 Subject: [PATCH 20/21] refactor: rename nft_ingest2 --- Cargo.lock | 80 +++++++++---------- Cargo.toml | 2 +- {nft_ingester2 => grpc-ingest}/Cargo.toml | 2 +- {nft_ingester2 => grpc-ingest}/README.md | 0 {nft_ingester2 => grpc-ingest}/build.rs | 0 .../config-download-metadata.yml | 0 .../config-grpc2redis.yml | 0 .../config-ingester.yml | 0 {nft_ingester2 => grpc-ingest}/src/config.rs | 0 .../src/download_metadata.rs | 0 {nft_ingester2 => grpc-ingest}/src/grpc.rs | 0 .../src/ingester.rs | 0 {nft_ingester2 => grpc-ingest}/src/main.rs | 0 .../src/postgres.rs | 0 {nft_ingester2 => grpc-ingest}/src/prom.rs | 0 {nft_ingester2 => grpc-ingest}/src/redis.rs | 0 {nft_ingester2 => grpc-ingest}/src/tracing.rs | 0 {nft_ingester2 => grpc-ingest}/src/util.rs | 0 {nft_ingester2 => grpc-ingest}/src/version.rs | 0 19 files changed, 42 insertions(+), 42 deletions(-) rename {nft_ingester2 => grpc-ingest}/Cargo.toml (98%) rename {nft_ingester2 => grpc-ingest}/README.md (100%) rename {nft_ingester2 => grpc-ingest}/build.rs (100%) rename {nft_ingester2 => grpc-ingest}/config-download-metadata.yml (100%) rename {nft_ingester2 => grpc-ingest}/config-grpc2redis.yml (100%) rename {nft_ingester2 => grpc-ingest}/config-ingester.yml (100%) rename {nft_ingester2 => grpc-ingest}/src/config.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/download_metadata.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/grpc.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/ingester.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/main.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/postgres.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/prom.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/redis.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/tracing.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/util.rs (100%) rename {nft_ingester2 => grpc-ingest}/src/version.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index 347dbf5c5..40e3b3e72 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1817,6 +1817,46 @@ dependencies = [ "tokio", ] +[[package]] +name = "das-grpc-ingest" +version = "0.7.2" +dependencies = [ + "anyhow", + "async-stream", + "atty", + "cargo-lock", + "chrono", + "clap 4.5.4", + "digital_asset_types", + "futures", + "git-version", + "hyper", + "json5", + "lazy_static", + "opentelemetry", + "opentelemetry-jaeger", + "opentelemetry_sdk", + "program_transformers", + "prometheus", + "redis 0.25.3", + "reqwest", + "rust-crypto", + "sea-orm", + "serde", + "serde_json", + "serde_yaml", + "solana-sdk", + "sqlx", + "tokio", + "tracing", + "tracing-opentelemetry", + "tracing-subscriber", + "vergen", + "yellowstone-grpc-client", + "yellowstone-grpc-proto", + "yellowstone-grpc-tools", +] + [[package]] name = "das-ops" version = "0.7.2" @@ -3724,46 +3764,6 @@ dependencies = [ "url", ] -[[package]] -name = "nft_ingester2" -version = "0.7.2" -dependencies = [ - "anyhow", - "async-stream", - "atty", - "cargo-lock", - "chrono", - "clap 4.5.4", - "digital_asset_types", - "futures", - "git-version", - "hyper", - "json5", - "lazy_static", - "opentelemetry", - "opentelemetry-jaeger", - "opentelemetry_sdk", - "program_transformers", - "prometheus", - "redis 0.25.3", - "reqwest", - "rust-crypto", - "sea-orm", - "serde", - "serde_json", - "serde_yaml", - "solana-sdk", - "sqlx", - "tokio", - "tracing", - "tracing-opentelemetry", - "tracing-subscriber", - "vergen", - "yellowstone-grpc-client", - "yellowstone-grpc-proto", - "yellowstone-grpc-tools", -] - [[package]] name = "nix" version = "0.26.4" diff --git a/Cargo.toml b/Cargo.toml index a666f375f..e6e1ddc28 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ members = [ "migration", "nft_ingester", "ops", - "nft_ingester2", + "grpc-ingest", "program_transformers", "tools/acc_forwarder", "tools/bgtask_creator", diff --git a/nft_ingester2/Cargo.toml b/grpc-ingest/Cargo.toml similarity index 98% rename from nft_ingester2/Cargo.toml rename to grpc-ingest/Cargo.toml index 51afb7b09..958bca6b4 100644 --- a/nft_ingester2/Cargo.toml +++ b/grpc-ingest/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "nft_ingester2" +name = "das-grpc-ingest" version = { workspace = true } edition = { workspace = true } repository = { workspace = true } diff --git a/nft_ingester2/README.md b/grpc-ingest/README.md similarity index 100% rename from nft_ingester2/README.md rename to grpc-ingest/README.md diff --git a/nft_ingester2/build.rs b/grpc-ingest/build.rs similarity index 100% rename from nft_ingester2/build.rs rename to grpc-ingest/build.rs diff --git a/nft_ingester2/config-download-metadata.yml b/grpc-ingest/config-download-metadata.yml similarity index 100% rename from nft_ingester2/config-download-metadata.yml rename to grpc-ingest/config-download-metadata.yml diff --git a/nft_ingester2/config-grpc2redis.yml b/grpc-ingest/config-grpc2redis.yml similarity index 100% rename from nft_ingester2/config-grpc2redis.yml rename to grpc-ingest/config-grpc2redis.yml diff --git a/nft_ingester2/config-ingester.yml b/grpc-ingest/config-ingester.yml similarity index 100% rename from nft_ingester2/config-ingester.yml rename to grpc-ingest/config-ingester.yml diff --git a/nft_ingester2/src/config.rs b/grpc-ingest/src/config.rs similarity index 100% rename from nft_ingester2/src/config.rs rename to grpc-ingest/src/config.rs diff --git a/nft_ingester2/src/download_metadata.rs b/grpc-ingest/src/download_metadata.rs similarity index 100% rename from nft_ingester2/src/download_metadata.rs rename to grpc-ingest/src/download_metadata.rs diff --git a/nft_ingester2/src/grpc.rs b/grpc-ingest/src/grpc.rs similarity index 100% rename from nft_ingester2/src/grpc.rs rename to grpc-ingest/src/grpc.rs diff --git a/nft_ingester2/src/ingester.rs b/grpc-ingest/src/ingester.rs similarity index 100% rename from nft_ingester2/src/ingester.rs rename to grpc-ingest/src/ingester.rs diff --git a/nft_ingester2/src/main.rs b/grpc-ingest/src/main.rs similarity index 100% rename from nft_ingester2/src/main.rs rename to grpc-ingest/src/main.rs diff --git a/nft_ingester2/src/postgres.rs b/grpc-ingest/src/postgres.rs similarity index 100% rename from nft_ingester2/src/postgres.rs rename to grpc-ingest/src/postgres.rs diff --git a/nft_ingester2/src/prom.rs b/grpc-ingest/src/prom.rs similarity index 100% rename from nft_ingester2/src/prom.rs rename to grpc-ingest/src/prom.rs diff --git a/nft_ingester2/src/redis.rs b/grpc-ingest/src/redis.rs similarity index 100% rename from nft_ingester2/src/redis.rs rename to grpc-ingest/src/redis.rs diff --git a/nft_ingester2/src/tracing.rs b/grpc-ingest/src/tracing.rs similarity index 100% rename from nft_ingester2/src/tracing.rs rename to grpc-ingest/src/tracing.rs diff --git a/nft_ingester2/src/util.rs b/grpc-ingest/src/util.rs similarity index 100% rename from nft_ingester2/src/util.rs rename to grpc-ingest/src/util.rs diff --git a/nft_ingester2/src/version.rs b/grpc-ingest/src/version.rs similarity index 100% rename from nft_ingester2/src/version.rs rename to grpc-ingest/src/version.rs From 294fa1a0c351e0bed0e826656842857ef68228c5 Mon Sep 17 00:00:00 2001 From: Kyle Espinola Date: Mon, 15 Apr 2024 13:24:27 +0200 Subject: [PATCH 21/21] fix: applying account and transction filters to grpc subscription request --- .github/workflows/test.yml | 2 +- grpc-ingest/README.md | 2 +- grpc-ingest/config-grpc2redis.yml | 18 ++++++++----- grpc-ingest/src/config.rs | 4 +-- grpc-ingest/src/grpc.rs | 25 +++++++++++++++--- nft_ingester/src/tasks/mod.rs | 4 +-- .../src/bubblegum/decompress.rs | 26 ------------------- program_transformers/src/lib.rs | 2 +- 8 files changed, 40 insertions(+), 43 deletions(-) delete mode 100644 program_transformers/src/bubblegum/decompress.rs diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 4f4b4111d..60f1b69ab 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -38,7 +38,7 @@ jobs: run: | cargo tree git checkout Cargo.lock - cargo tree --frozen + cargo tree # fmt - name: Check fmt diff --git a/grpc-ingest/README.md b/grpc-ingest/README.md index a2afa2226..d721d863b 100644 --- a/grpc-ingest/README.md +++ b/grpc-ingest/README.md @@ -30,4 +30,4 @@ psql: ``` PGPASSWORD=solana psql -h localhost -U solana -d solana -``` +``` \ No newline at end of file diff --git a/grpc-ingest/config-grpc2redis.yml b/grpc-ingest/config-grpc2redis.yml index 73ed908f4..a7e79d1dc 100644 --- a/grpc-ingest/config-grpc2redis.yml +++ b/grpc-ingest/config-grpc2redis.yml @@ -1,21 +1,25 @@ prometheus: 127.0.0.1:8873 endpoint: http://127.0.0.1:10000 x_token: null -commitment: processed +commitment: finalized accounts: stream: ACCOUNTS stream_maxlen: 100_000_000 stream_data_key: data - filters: - - owner: - - TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA - - metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s + filter: + owner: + - "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s" + - "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" + - "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" + - "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" + - "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY" + - "CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d" transactions: stream: TRANSACTIONS stream_maxlen: 10_000_000 stream_data_key: data - filters: - - account_include: + filter: + account_include: - BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY redis: url: redis://localhost:6379 diff --git a/grpc-ingest/src/config.rs b/grpc-ingest/src/config.rs index c3c45531e..90b7c005c 100644 --- a/grpc-ingest/src/config.rs +++ b/grpc-ingest/src/config.rs @@ -61,7 +61,7 @@ pub struct ConfigGrpcAccounts { #[serde(default = "ConfigGrpcAccounts::default_stream_data_key")] pub stream_data_key: String, - pub filters: Vec, + pub filter: ConfigGrpcRequestAccounts, } impl ConfigGrpcAccounts { @@ -90,7 +90,7 @@ pub struct ConfigGrpcTransactions { #[serde(default = "ConfigGrpcTransactions::default_stream_data_key")] pub stream_data_key: String, - pub filters: Vec, + pub filter: ConfigGrpcRequestTransactions, } impl ConfigGrpcTransactions { diff --git a/grpc-ingest/src/grpc.rs b/grpc-ingest/src/grpc.rs index 01387c025..47cf9c718 100644 --- a/grpc-ingest/src/grpc.rs +++ b/grpc-ingest/src/grpc.rs @@ -5,6 +5,7 @@ use { anyhow::Context, futures::stream::StreamExt, redis::{streams::StreamMaxlen, RedisResult, Value as RedisValue}, + std::collections::HashMap, std::{sync::Arc, time::Duration}, tokio::{ task::JoinSet, @@ -12,7 +13,10 @@ use { }, tracing::warn, yellowstone_grpc_client::GeyserGrpcClient, - yellowstone_grpc_proto::{prelude::subscribe_update::UpdateOneof, prost::Message}, + yellowstone_grpc_proto::{ + geyser::SubscribeRequest, prelude::subscribe_update::UpdateOneof, prost::Message, + }, + yellowstone_grpc_tools::config::GrpcRequestToProto, }; pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { @@ -41,7 +45,22 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { .connect() .await .context("failed to connect go gRPC")?; - let (mut _subscribe_tx, mut stream) = client.subscribe().await?; + + let mut accounts = HashMap::with_capacity(1); + let mut transactions = HashMap::with_capacity(1); + + accounts.insert("das".to_string(), config.accounts.filter.clone().to_proto()); + transactions.insert( + "das".to_string(), + config.transactions.filter.clone().to_proto(), + ); + + let request = SubscribeRequest { + accounts, + transactions, + ..Default::default() + }; + let (mut _subscribe_tx, mut stream) = client.subscribe_with_request(Some(request)).await?; // recv-send loop let mut shutdown = create_shutdown()?; @@ -117,7 +136,7 @@ pub async fn run(config: ConfigGrpc) -> anyhow::Result<()> { let result: RedisResult = pipe.atomic().query_async(&mut connection).await; - let status = if result.is_ok() { Ok(()) } else { Err(()) }; + let status = result.map(|_| ()).map_err(|_| ()); redis_xadd_status_inc(&config.accounts.stream, status, pipe_accounts); redis_xadd_status_inc(&config.transactions.stream, status, pipe_transactions); diff --git a/nft_ingester/src/tasks/mod.rs b/nft_ingester/src/tasks/mod.rs index ec7a813fe..6c6f854b6 100644 --- a/nft_ingester/src/tasks/mod.rs +++ b/nft_ingester/src/tasks/mod.rs @@ -324,8 +324,8 @@ impl TaskManager { tokio::task::spawn(async move { while let Some(task) = receiver.recv().await { if let Some(task_created_time) = task.created_at { - let bus_time = - Utc::now().timestamp_millis() - task_created_time.timestamp_millis(); + let bus_time = Utc::now().timestamp_millis() + - task_created_time.and_utc().timestamp_millis(); metric! { statsd_histogram!("ingester.bgtask.bus_time", bus_time as u64, "type" => task.name); } diff --git a/program_transformers/src/bubblegum/decompress.rs b/program_transformers/src/bubblegum/decompress.rs deleted file mode 100644 index 208e9aabc..000000000 --- a/program_transformers/src/bubblegum/decompress.rs +++ /dev/null @@ -1,26 +0,0 @@ -use { - crate::{ - bubblegum::db::{ - upsert_asset_with_compression_info, upsert_asset_with_leaf_info_for_decompression, - }, - error::ProgramTransformerResult, - }, - blockbuster::{instruction::InstructionBundle, programs::bubblegum::BubblegumInstruction}, - sea_orm::{ConnectionTrait, TransactionTrait}, -}; - -pub async fn decompress<'c, T>( - _parsing_result: &BubblegumInstruction, - bundle: &InstructionBundle<'c>, - txn: &'c T, -) -> ProgramTransformerResult<()> -where - T: ConnectionTrait + TransactionTrait, -{ - let id_bytes = bundle.keys.get(3).unwrap().to_bytes().to_vec(); - - // Partial update of asset table with just leaf. - upsert_asset_with_leaf_info_for_decompression(txn, id_bytes.clone()).await?; - upsert_asset_with_compression_info(txn, id_bytes.clone(), false, false, 1, Some(id_bytes), true) - .await -} diff --git a/program_transformers/src/lib.rs b/program_transformers/src/lib.rs index 6b6259d01..79c407bd4 100644 --- a/program_transformers/src/lib.rs +++ b/program_transformers/src/lib.rs @@ -53,7 +53,7 @@ pub struct TransactionInfo { pub meta_inner_instructions: Vec, } -#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)] +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct DownloadMetadataInfo { asset_data_id: Vec, uri: String,