use {
juniper::{graphql_object, FieldResult},
std::str::FromStr,
};
pub struct QueryRoot;
#[graphql_object(context = crate::graphql::context::GraphQLContext)]
impl QueryRoot {
async fn escrow_p_d_a(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::EscrowPDAGraphQL>> {
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::EscrowPDARow::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_escrow_p_d_a(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::EscrowPDAGraphQL>> {
let rows: Vec<crate::accounts::postgres::EscrowPDARow> = sqlx::query_as(
r#"SELECT * FROM escrow_p_d_a_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 loan(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::LoanGraphQL>> {
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::LoanRow::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_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::LoanGraphQL>> {
let rows: Vec<crate::accounts::postgres::LoanRow> =
sqlx::query_as(r#"SELECT * FROM loan_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 n_f_t_list(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::NFTListGraphQL>> {
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::NFTListRow::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_n_f_t_list(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::NFTListGraphQL>> {
let rows: Vec<crate::accounts::postgres::NFTListRow> = sqlx::query_as(
r#"SELECT * FROM n_f_t_list_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 order_book(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::OrderBookGraphQL>> {
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::OrderBookRow::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_order_book(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::OrderBookGraphQL>> {
let rows: Vec<crate::accounts::postgres::OrderBookRow> = sqlx::query_as(
r#"SELECT * FROM order_book_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 price_update_v2(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::PriceUpdateV2GraphQL>> {
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::PriceUpdateV2Row::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_price_update_v2(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::PriceUpdateV2GraphQL>> {
let rows: Vec<crate::accounts::postgres::PriceUpdateV2Row> = sqlx::query_as(
r#"SELECT * FROM price_update_v2_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 program_version(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::ProgramVersionGraphQL>> {
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::ProgramVersionRow::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_program_version(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::ProgramVersionGraphQL>> {
let rows: Vec<crate::accounts::postgres::ProgramVersionRow> = sqlx::query_as(
r#"SELECT * FROM program_version_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_lending_loan(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::TokenLendingLoanGraphQL>> {
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::TokenLendingLoanRow::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_lending_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::TokenLendingLoanGraphQL>> {
let rows: Vec<crate::accounts::postgres::TokenLendingLoanRow> = sqlx::query_as(
r#"SELECT * FROM token_lending_loan_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_lending_order_book(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::TokenLendingOrderBookGraphQL>> {
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::TokenLendingOrderBookRow::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_lending_order_book(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::TokenLendingOrderBookGraphQL>> {
let rows: Vec<crate::accounts::postgres::TokenLendingOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM token_lending_order_book_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_lending_pool(
context: &crate::graphql::context::GraphQLContext,
pubkey: String,
) -> FieldResult<Option<crate::accounts::graphql::TokenLendingPoolGraphQL>> {
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::TokenLendingPoolRow::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_lending_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::accounts::graphql::TokenLendingPoolGraphQL>> {
let rows: Vec<crate::accounts::postgres::TokenLendingPoolRow> = sqlx::query_as(
r#"SELECT * FROM token_lending_pool_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 add_liquidity_token_pool(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::AddLiquidityTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::AddLiquidityTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM add_liquidity_token_pool_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_add_liquidity_token_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::AddLiquidityTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::AddLiquidityTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM add_liquidity_token_pool_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_escrow_value_mint_ata_admin(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseEscrowValueMintAtaAdminGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseEscrowValueMintAtaAdminRow> = sqlx::query_as(
r#"SELECT * FROM close_escrow_value_mint_ata_admin_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_escrow_value_mint_ata_admin(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseEscrowValueMintAtaAdminGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseEscrowValueMintAtaAdminRow> = sqlx::query_as(
r#"SELECT * FROM close_escrow_value_mint_ata_admin_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_nft_list(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseNftListRow> = sqlx::query_as(
r#"SELECT * FROM close_nft_list_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_nft_list(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseNftListRow> = sqlx::query_as(
r#"SELECT * FROM close_nft_list_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_order_book(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM close_order_book_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_order_book(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM close_order_book_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_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM close_token_orderbook_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_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM close_token_orderbook_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_token_pool(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM close_token_pool_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_token_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CloseTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::CloseTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM close_token_pool_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 create_nft_list(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateNftListRow> = sqlx::query_as(
r#"SELECT * FROM create_nft_list_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_create_nft_list(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateNftListRow> = sqlx::query_as(
r#"SELECT * FROM create_nft_list_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 create_order_book(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM create_order_book_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_create_order_book(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM create_order_book_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 create_program_version(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateProgramVersionGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateProgramVersionRow> = sqlx::query_as(
r#"SELECT * FROM create_program_version_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_create_program_version(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateProgramVersionGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateProgramVersionRow> = sqlx::query_as(
r#"SELECT * FROM create_program_version_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 create_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM create_token_orderbook_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_create_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM create_token_orderbook_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 create_token_pool(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM create_token_pool_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_create_token_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::CreateTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::CreateTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM create_token_pool_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 extend_loan_core(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM extend_loan_core_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_extend_loan_core(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM extend_loan_core_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 extend_loan_v3(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM extend_loan_v3_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_extend_loan_v3(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM extend_loan_v3_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 extend_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM extend_loan_v3_compressed_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_extend_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM extend_loan_v3_compressed_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 extend_token_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM extend_token_loan_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_extend_token_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ExtendTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::ExtendTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM extend_token_loan_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 foreclose_loan_core(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_core_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_foreclose_loan_core(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_core_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 foreclose_loan_v3(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_v3_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_foreclose_loan_v3(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_v3_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 foreclose_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_v3_compressed_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_foreclose_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_loan_v3_compressed_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 foreclose_token_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_token_loan_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_foreclose_token_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::ForecloseTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::ForecloseTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM foreclose_token_loan_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 offer_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::OfferLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::OfferLoanRow> = sqlx::query_as(
r#"SELECT * FROM offer_loan_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_offer_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::OfferLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::OfferLoanRow> = sqlx::query_as(
r#"SELECT * FROM offer_loan_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 repay_loan_core(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM repay_loan_core_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_repay_loan_core(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM repay_loan_core_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 repay_loan_v3(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM repay_loan_v3_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_repay_loan_v3(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM repay_loan_v3_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 repay_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM repay_loan_v3_compressed_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_repay_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM repay_loan_v3_compressed_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 repay_token_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM repay_token_loan_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_repay_token_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RepayTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::RepayTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM repay_token_loan_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 rescind_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RescindLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::RescindLoanRow> = sqlx::query_as(
r#"SELECT * FROM rescind_loan_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_rescind_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::RescindLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::RescindLoanRow> = sqlx::query_as(
r#"SELECT * FROM rescind_loan_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 take_loan_core(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM take_loan_core_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_take_loan_core(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanCoreGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanCoreRow> = sqlx::query_as(
r#"SELECT * FROM take_loan_core_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 take_loan_v3(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM take_loan_v3_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_take_loan_v3(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanV3GraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanV3Row> = sqlx::query_as(
r#"SELECT * FROM take_loan_v3_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 take_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM take_loan_v3_compressed_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_take_loan_v3_compressed(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeLoanV3CompressedGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeLoanV3CompressedRow> = sqlx::query_as(
r#"SELECT * FROM take_loan_v3_compressed_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 take_token_loan(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM take_token_loan_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_take_token_loan(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::TakeTokenLoanGraphQL>> {
let rows: Vec<crate::instructions::postgres::TakeTokenLoanRow> = sqlx::query_as(
r#"SELECT * FROM take_token_loan_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 update_nft_list(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateNftListRow> = sqlx::query_as(
r#"SELECT * FROM update_nft_list_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_update_nft_list(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateNftListGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateNftListRow> = sqlx::query_as(
r#"SELECT * FROM update_nft_list_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 update_order_book(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM update_order_book_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_update_order_book(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateOrderBookGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateOrderBookRow> = sqlx::query_as(
r#"SELECT * FROM update_order_book_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 update_program_version(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateProgramVersionGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateProgramVersionRow> = sqlx::query_as(
r#"SELECT * FROM update_program_version_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_update_program_version(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateProgramVersionGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateProgramVersionRow> = sqlx::query_as(
r#"SELECT * FROM update_program_version_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 update_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM update_token_orderbook_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_update_token_orderbook(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateTokenOrderbookGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateTokenOrderbookRow> = sqlx::query_as(
r#"SELECT * FROM update_token_orderbook_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 update_token_pool(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM update_token_pool_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_update_token_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::UpdateTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::UpdateTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM update_token_pool_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_liquidity_token_pool(
context: &crate::graphql::context::GraphQLContext,
signature: String,
instruction_index: i32,
) -> FieldResult<Vec<crate::instructions::graphql::WithdrawLiquidityTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::WithdrawLiquidityTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM withdraw_liquidity_token_pool_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_liquidity_token_pool(
context: &crate::graphql::context::GraphQLContext,
limit: i32,
offset: i32,
) -> FieldResult<Vec<crate::instructions::graphql::WithdrawLiquidityTokenPoolGraphQL>> {
let rows: Vec<crate::instructions::postgres::WithdrawLiquidityTokenPoolRow> = sqlx::query_as(
r#"SELECT * FROM withdraw_liquidity_token_pool_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())
}
}