use {
juniper::{graphql_object, FieldResult},
std::str::FromStr,
};
pub struct QueryRoot;
#[graphql_object(context = crate::graphql::context::GraphQLContext)]
impl QueryRoot {
async fn mint(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::MintGraphQL>> {
use carbon_core::postgres::{operations::Lookup, primitives::Pubkey as PgPubkey};
let pk = PgPubkey(
solana_pubkey::Pubkey::from_str(&pubkey)
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?,
);
let row = crate::accounts::postgres::MintRow::lookup(pk, &context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(row.and_then(|row| row.try_into().ok()))
}
async fn list_mint(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::MintGraphQL>> {
let rows: Vec<crate::accounts::postgres::MintRow> =
sqlx::query_as(r#"SELECT * FROM mint_account ORDER BY __slot DESC LIMIT $1 OFFSET $2"#)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn token(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::TokenGraphQL>> {
use carbon_core::postgres::{operations::Lookup, primitives::Pubkey as PgPubkey};
let pk = PgPubkey(
solana_pubkey::Pubkey::from_str(&pubkey)
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?,
);
let row = crate::accounts::postgres::TokenRow::lookup(pk, &context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(row.and_then(|row| row.try_into().ok()))
}
async fn list_token(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::TokenGraphQL>> {
let rows: Vec<crate::accounts::postgres::TokenRow> = sqlx::query_as(
r#"SELECT * FROM token_account ORDER BY __slot DESC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn multisig(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::MultisigGraphQL>> {
use carbon_core::postgres::{operations::Lookup, primitives::Pubkey as PgPubkey};
let pk = PgPubkey(
solana_pubkey::Pubkey::from_str(&pubkey)
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?,
);
let row = crate::accounts::postgres::MultisigRow::lookup(pk, &context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(row.and_then(|row| row.try_into().ok()))
}
async fn list_multisig(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::MultisigGraphQL>> {
let rows: Vec<crate::accounts::postgres::MultisigRow> = sqlx::query_as(
r#"SELECT * FROM multisig_account ORDER BY __slot DESC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_mint(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMintGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMintRow> = sqlx::query_as(
r#"SELECT * FROM initialize_mint_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_mint(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMintGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMintRow> = sqlx::query_as(
r#"SELECT * FROM initialize_mint_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_account(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccountRow> = sqlx::query_as(
r#"SELECT * FROM initialize_account_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_account(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccountRow> = sqlx::query_as(
r#"SELECT * FROM initialize_account_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_multisig(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMultisigGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMultisigRow> = sqlx::query_as(
r#"SELECT * FROM initialize_multisig_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_multisig(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMultisigGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMultisigRow> = sqlx::query_as(
r#"SELECT * FROM initialize_multisig_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn transfer(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TransferGraphQL>> {
let rows: Vec<crate::instructions::postgres::TransferRow> = sqlx::query_as(
r#"SELECT * FROM transfer_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_transfer(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TransferGraphQL>> {
let rows: Vec<crate::instructions::postgres::TransferRow> = sqlx::query_as(
r#"SELECT * FROM transfer_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn approve(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ApproveGraphQL>> {
let rows: Vec<crate::instructions::postgres::ApproveRow> = sqlx::query_as(
r#"SELECT * FROM approve_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_approve(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ApproveGraphQL>> {
let rows: Vec<crate::instructions::postgres::ApproveRow> = sqlx::query_as(
r#"SELECT * FROM approve_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn revoke(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RevokeGraphQL>> {
let rows: Vec<crate::instructions::postgres::RevokeRow> = sqlx::query_as(
r#"SELECT * FROM revoke_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_revoke(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RevokeGraphQL>> {
let rows: Vec<crate::instructions::postgres::RevokeRow> = sqlx::query_as(
r#"SELECT * FROM revoke_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn set_authority(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::SetAuthorityGraphQL>> {
let rows: Vec<crate::instructions::postgres::SetAuthorityRow> = sqlx::query_as(
r#"SELECT * FROM set_authority_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_set_authority(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::SetAuthorityGraphQL>> {
let rows: Vec<crate::instructions::postgres::SetAuthorityRow> = sqlx::query_as(
r#"SELECT * FROM set_authority_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn mint_to(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::MintToGraphQL>> {
let rows: Vec<crate::instructions::postgres::MintToRow> = sqlx::query_as(
r#"SELECT * FROM mint_to_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_mint_to(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::MintToGraphQL>> {
let rows: Vec<crate::instructions::postgres::MintToRow> = sqlx::query_as(
r#"SELECT * FROM mint_to_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn burn(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BurnGraphQL>> {
let rows: Vec<crate::instructions::postgres::BurnRow> = sqlx::query_as(
r#"SELECT * FROM burn_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_burn(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BurnGraphQL>> {
let rows: Vec<crate::instructions::postgres::BurnRow> = sqlx::query_as(
r#"SELECT * FROM burn_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn close_account(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseAccountRow> = sqlx::query_as(
r#"SELECT * FROM close_account_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_close_account(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseAccountRow> = sqlx::query_as(
r#"SELECT * FROM close_account_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn freeze_account(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::FreezeAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::FreezeAccountRow> = sqlx::query_as(
r#"SELECT * FROM freeze_account_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_freeze_account(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::FreezeAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::FreezeAccountRow> = sqlx::query_as(
r#"SELECT * FROM freeze_account_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn thaw_account(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ThawAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::ThawAccountRow> = sqlx::query_as(
r#"SELECT * FROM thaw_account_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_thaw_account(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ThawAccountGraphQL>> {
let rows: Vec<crate::instructions::postgres::ThawAccountRow> = sqlx::query_as(
r#"SELECT * FROM thaw_account_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn transfer_checked(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TransferCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::TransferCheckedRow> = sqlx::query_as(
r#"SELECT * FROM transfer_checked_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_transfer_checked(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TransferCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::TransferCheckedRow> = sqlx::query_as(
r#"SELECT * FROM transfer_checked_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn approve_checked(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ApproveCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ApproveCheckedRow> = sqlx::query_as(
r#"SELECT * FROM approve_checked_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_approve_checked(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ApproveCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ApproveCheckedRow> = sqlx::query_as(
r#"SELECT * FROM approve_checked_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn mint_to_checked(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::MintToCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::MintToCheckedRow> = sqlx::query_as(
r#"SELECT * FROM mint_to_checked_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_mint_to_checked(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::MintToCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::MintToCheckedRow> = sqlx::query_as(
r#"SELECT * FROM mint_to_checked_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn burn_checked(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BurnCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::BurnCheckedRow> = sqlx::query_as(
r#"SELECT * FROM burn_checked_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_burn_checked(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BurnCheckedGraphQL>> {
let rows: Vec<crate::instructions::postgres::BurnCheckedRow> = sqlx::query_as(
r#"SELECT * FROM burn_checked_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_account2(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccount2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccount2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_account2_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_account2(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccount2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccount2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_account2_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn sync_native(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::SyncNativeGraphQL>> {
let rows: Vec<crate::instructions::postgres::SyncNativeRow> = sqlx::query_as(
r#"SELECT * FROM sync_native_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_sync_native(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::SyncNativeGraphQL>> {
let rows: Vec<crate::instructions::postgres::SyncNativeRow> = sqlx::query_as(
r#"SELECT * FROM sync_native_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_account3(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccount3GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccount3Row> = sqlx::query_as(
r#"SELECT * FROM initialize_account3_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_account3(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeAccount3GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeAccount3Row> = sqlx::query_as(
r#"SELECT * FROM initialize_account3_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_multisig2(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMultisig2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMultisig2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_multisig2_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_multisig2(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMultisig2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMultisig2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_multisig2_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_mint2(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMint2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMint2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_mint2_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_mint2(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeMint2GraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeMint2Row> = sqlx::query_as(
r#"SELECT * FROM initialize_mint2_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn get_account_data_size(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::GetAccountDataSizeGraphQL>> {
let rows: Vec<crate::instructions::postgres::GetAccountDataSizeRow> = sqlx::query_as(
r#"SELECT * FROM get_account_data_size_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_get_account_data_size(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::GetAccountDataSizeGraphQL>> {
let rows: Vec<crate::instructions::postgres::GetAccountDataSizeRow> = sqlx::query_as(
r#"SELECT * FROM get_account_data_size_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn initialize_immutable_owner(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeImmutableOwnerGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeImmutableOwnerRow> = sqlx::query_as(
r#"SELECT * FROM initialize_immutable_owner_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_initialize_immutable_owner(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::InitializeImmutableOwnerGraphQL>> {
let rows: Vec<crate::instructions::postgres::InitializeImmutableOwnerRow> = sqlx::query_as(
r#"SELECT * FROM initialize_immutable_owner_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn amount_to_ui_amount(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::AmountToUiAmountGraphQL>> {
let rows: Vec<crate::instructions::postgres::AmountToUiAmountRow> = sqlx::query_as(
r#"SELECT * FROM amount_to_ui_amount_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_amount_to_ui_amount(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::AmountToUiAmountGraphQL>> {
let rows: Vec<crate::instructions::postgres::AmountToUiAmountRow> = sqlx::query_as(
r#"SELECT * FROM amount_to_ui_amount_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn ui_amount_to_amount(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UiAmountToAmountGraphQL>> {
let rows: Vec<crate::instructions::postgres::UiAmountToAmountRow> = sqlx::query_as(
r#"SELECT * FROM ui_amount_to_amount_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_ui_amount_to_amount(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UiAmountToAmountGraphQL>> {
let rows: Vec<crate::instructions::postgres::UiAmountToAmountRow> = sqlx::query_as(
r#"SELECT * FROM ui_amount_to_amount_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn withdraw_excess_lamports(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::WithdrawExcessLamportsGraphQL>> {
let rows: Vec<crate::instructions::postgres::WithdrawExcessLamportsRow> = sqlx::query_as(
r#"SELECT * FROM withdraw_excess_lamports_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_withdraw_excess_lamports(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::WithdrawExcessLamportsGraphQL>> {
let rows: Vec<crate::instructions::postgres::WithdrawExcessLamportsRow> = sqlx::query_as(
r#"SELECT * FROM withdraw_excess_lamports_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn unwrap_lamports(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UnwrapLamportsGraphQL>> {
let rows: Vec<crate::instructions::postgres::UnwrapLamportsRow> = sqlx::query_as(
r#"SELECT * FROM unwrap_lamports_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_unwrap_lamports(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UnwrapLamportsGraphQL>> {
let rows: Vec<crate::instructions::postgres::UnwrapLamportsRow> = sqlx::query_as(
r#"SELECT * FROM unwrap_lamports_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn batch(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BatchGraphQL>> {
let rows: Vec<crate::instructions::postgres::BatchRow> = sqlx::query_as(
r#"SELECT * FROM batch_instruction WHERE __signature = $1 AND __instruction_index = $2 ORDER BY __stack_height ASC"#,
)
.bind(signature)
.bind(instruction_index)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
async fn list_batch(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::BatchGraphQL>> {
let rows: Vec<crate::instructions::postgres::BatchRow> = sqlx::query_as(
r#"SELECT * FROM batch_instruction ORDER BY __slot DESC, __signature DESC, __instruction_index ASC LIMIT $1 OFFSET $2"#,
)
.bind(limit)
.bind(offset)
.fetch_all(&*context.pool)
.await
.map_err(|e| juniper::FieldError::new(e.to_string(), juniper::Value::null()))?;
Ok(rows
.into_iter()
.filter_map(|row| row.try_into().ok())
.collect())
}
}