koios_sdk/models/
requests.rs

use serde::{Deserialize, Serialize};

/// Request body for block hashes
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockHashesRequest {
    #[serde(rename = "_block_hashes")]
    pub block_hashes: Vec<String>,
}

/// Request body for detailed block transaction information
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct BlockTxInfoRequest {
    #[serde(rename = "_block_hashes")]
    pub block_hashes: Vec<String>,
    #[serde(rename = "_inputs", skip_serializing_if = "Option::is_none")]
    pub inputs: Option<bool>,
    #[serde(rename = "_metadata", skip_serializing_if = "Option::is_none")]
    pub metadata: Option<bool>,
    #[serde(rename = "_assets", skip_serializing_if = "Option::is_none")]
    pub assets: Option<bool>,
    #[serde(rename = "_withdrawals", skip_serializing_if = "Option::is_none")]
    pub withdrawals: Option<bool>,
    #[serde(rename = "_certs", skip_serializing_if = "Option::is_none")]
    pub certs: Option<bool>,
    #[serde(rename = "_scripts", skip_serializing_if = "Option::is_none")]
    pub scripts: Option<bool>,
    #[serde(rename = "_bytecode", skip_serializing_if = "Option::is_none")]
    pub bytecode: Option<bool>,
}

/// Request body for payment addresses
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentAddressesRequest {
    #[serde(rename = "_addresses")]
    pub addresses: Vec<String>,
}

/// Request body for payment addresses with extended flag
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaymentAddressesWithExtendedRequest {
    #[serde(rename = "_addresses")]
    pub addresses: Vec<String>,
    #[serde(rename = "_extended", skip_serializing_if = "Option::is_none")]
    pub extended: Option<bool>,
}

/// Request body for address transactions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AddressTransactionsRequest {
    #[serde(rename = "_addresses")]
    pub addresses: Vec<String>,
    #[serde(
        rename = "_after_block_height",
        skip_serializing_if = "Option::is_none"
    )]
    pub after_block_height: Option<u64>,
}

/// Request body for stake addresses with epoch number
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StakeAddressesWithEpochRequest {
    #[serde(rename = "_stake_addresses")]
    pub stake_addresses: Vec<String>,
    #[serde(rename = "_epoch_no", skip_serializing_if = "Option::is_none")]
    pub epoch_no: Option<u64>,
}

/// Request body for stake addresses with first only and empty flags
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StakeAddressesWithFirstOnlyAndEmptyRequest {
    #[serde(rename = "_stake_addresses")]
    pub stake_addresses: Vec<String>,
    #[serde(rename = "_first_only", skip_serializing_if = "Option::is_none")]
    pub first_only: Option<bool>,
    #[serde(rename = "_empty", skip_serializing_if = "Option::is_none")]
    pub empty: Option<bool>,
}

/// Request body for stake addresses with extended flag
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StakeAddressesWithExtendedRequest {
    #[serde(rename = "_stake_addresses")]
    pub stake_addresses: Vec<String>,
    #[serde(rename = "_extended", skip_serializing_if = "Option::is_none")]
    pub extended: Option<bool>,
}

/// Request body for stake addresses
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StakeAddressesRequest {
    #[serde(rename = "_stake_addresses")]
    pub stake_addresses: Vec<String>,
}

/// Request body for credential transactions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CredentialTransactionsRequest {
    #[serde(rename = "_payment_credentials")]
    pub payment_credentials: Vec<String>,
    #[serde(
        rename = "_after_block_height",
        skip_serializing_if = "Option::is_none"
    )]
    pub after_block_height: Option<u64>,
}

/// Request body for credential UTXOs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CredentialUtxosRequest {
    #[serde(rename = "_payment_credentials")]
    pub payment_credentials: Vec<String>,
    #[serde(rename = "_extended", skip_serializing_if = "Option::is_none")]
    pub extended: Option<bool>,
}

/// Request body for transaction IDs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionIdsRequest {
    #[serde(rename = "_tx_hashes")]
    pub tx_hashes: Vec<String>,
}

/// Request body for transaction information
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct TransactionInfoRequest {
    #[serde(rename = "_tx_hashes")]
    pub tx_hashes: Vec<String>,
    #[serde(rename = "_inputs", skip_serializing_if = "Option::is_none")]
    pub inputs: Option<bool>,
    #[serde(rename = "_metadata", skip_serializing_if = "Option::is_none")]
    pub metadata: Option<bool>,
    #[serde(rename = "_assets", skip_serializing_if = "Option::is_none")]
    pub assets: Option<bool>,
    #[serde(rename = "_withdrawals", skip_serializing_if = "Option::is_none")]
    pub withdrawals: Option<bool>,
    #[serde(rename = "_certs", skip_serializing_if = "Option::is_none")]
    pub certs: Option<bool>,
    #[serde(rename = "_scripts", skip_serializing_if = "Option::is_none")]
    pub scripts: Option<bool>,
    #[serde(rename = "_bytecode", skip_serializing_if = "Option::is_none")]
    pub bytecode: Option<bool>,
    #[serde(rename = "_governance", skip_serializing_if = "Option::is_none")]
    pub governance: Option<bool>,
}

/// Request body for pool IDs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolIdsRequest {
    #[serde(rename = "_pool_bech32_ids")]
    pub pool_bech32_ids: Vec<String>,
}

/// Request body for optional pool IDs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolIdsOptionalRequest {
    #[serde(rename = "_pool_bech32_ids", skip_serializing_if = "Option::is_none")]
    pub pool_bech32_ids: Option<Vec<String>>,
}

/// Request body for script hashes
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScriptHashesRequest {
    #[serde(rename = "_script_hashes")]
    pub script_hashes: Vec<String>,
}

/// Request body for datum hashes
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatumHashesRequest {
    #[serde(rename = "_datum_hashes")]
    pub datum_hashes: Vec<String>,
}

/// Request body for asset list
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AssetListRequest {
    #[serde(rename = "_asset_list")]
    pub asset_list: Vec<Vec<String>>,
}

/// Request body for asset list with extended flag
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AssetListWithExtendedRequest {
    #[serde(rename = "_asset_list")]
    pub asset_list: Vec<Vec<String>>,
    #[serde(rename = "_extended", skip_serializing_if = "Option::is_none")]
    pub extended: Option<bool>,
}

/// Request body for DRep ID bulk
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DrepIdBulkRequest {
    #[serde(rename = "_drep_ids")]
    pub drep_ids: Vec<String>,
}

/// Request body for UTXO references with extended flag
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UtxoRefsWithExtendedRequest {
    #[serde(rename = "_utxo_refs")]
    pub utxo_refs: Vec<String>,
    #[serde(rename = "_extended", skip_serializing_if = "Option::is_none")]
    pub extended: Option<bool>,
}

/// Request body for Ogmios requests
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OgmiosRequest {
    pub jsonrpc: String,
    pub method: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub params: Option<serde_json::Value>,
}

// Implementation blocks for constructors
impl BlockHashesRequest {
    pub fn new(block_hashes: Vec<String>) -> Self {
        Self { block_hashes }
    }
}

impl BlockTxInfoRequest {
    pub fn new(block_hashes: Vec<String>) -> Self {
        Self {
            block_hashes,
            inputs: None,
            metadata: None,
            assets: None,
            withdrawals: None,
            certs: None,
            scripts: None,
            bytecode: None,
        }
    }
}

impl PaymentAddressesRequest {
    pub fn new(addresses: Vec<String>) -> Self {
        Self { addresses }
    }
}

impl PaymentAddressesWithExtendedRequest {
    pub fn new(addresses: Vec<String>, extended: Option<bool>) -> Self {
        Self {
            addresses,
            extended,
        }
    }
}

impl StakeAddressesRequest {
    pub fn new(stake_addresses: Vec<String>) -> Self {
        Self { stake_addresses }
    }
}

impl AddressTransactionsRequest {
    pub fn new(addresses: Vec<String>, after_block_height: Option<u64>) -> Self {
        Self {
            addresses,
            after_block_height,
        }
    }
}

impl StakeAddressesWithEpochRequest {
    pub fn new(stake_addresses: Vec<String>, epoch_no: Option<u64>) -> Self {
        Self {
            stake_addresses,
            epoch_no,
        }
    }
}

impl StakeAddressesWithFirstOnlyAndEmptyRequest {
    pub fn new(
        stake_addresses: Vec<String>,
        first_only: Option<bool>,
        empty: Option<bool>,
    ) -> Self {
        Self {
            stake_addresses,
            first_only,
            empty,
        }
    }
}

impl StakeAddressesWithExtendedRequest {
    pub fn new(stake_addresses: Vec<String>, extended: Option<bool>) -> Self {
        Self {
            stake_addresses,
            extended,
        }
    }
}

impl CredentialTransactionsRequest {
    pub fn new(payment_credentials: Vec<String>, after_block_height: Option<u64>) -> Self {
        Self {
            payment_credentials,
            after_block_height,
        }
    }
}

impl CredentialUtxosRequest {
    pub fn new(payment_credentials: Vec<String>, extended: Option<bool>) -> Self {
        Self {
            payment_credentials,
            extended,
        }
    }
}

impl TransactionIdsRequest {
    pub fn new(tx_hashes: Vec<String>) -> Self {
        Self { tx_hashes }
    }
}

impl TransactionInfoRequest {
    pub fn new(tx_hashes: Vec<String>) -> Self {
        Self {
            tx_hashes,
            inputs: None,
            metadata: None,
            assets: None,
            withdrawals: None,
            certs: None,
            scripts: None,
            bytecode: None,
            governance: None,
        }
    }

    pub fn with_options(
        tx_hashes: Vec<String>,
        inputs: Option<bool>,
        metadata: Option<bool>,
        assets: Option<bool>,
        withdrawals: Option<bool>,
        certs: Option<bool>,
        scripts: Option<bool>,
        bytecode: Option<bool>,
        governance: Option<bool>,
    ) -> Self {
        Self {
            tx_hashes,
            inputs,
            metadata,
            assets,
            withdrawals,
            certs,
            scripts,
            bytecode,
            governance,
        }
    }
}

impl PoolIdsRequest {
    pub fn new(pool_bech32_ids: Vec<String>) -> Self {
        Self { pool_bech32_ids }
    }
}

impl PoolIdsOptionalRequest {
    pub fn new(pool_bech32_ids: Option<Vec<String>>) -> Self {
        Self { pool_bech32_ids }
    }
}

impl ScriptHashesRequest {
    pub fn new(script_hashes: Vec<String>) -> Self {
        Self { script_hashes }
    }
}

impl DatumHashesRequest {
    pub fn new(datum_hashes: Vec<String>) -> Self {
        Self { datum_hashes }
    }
}

impl AssetListRequest {
    pub fn new(asset_list: Vec<Vec<String>>) -> Self {
        Self { asset_list }
    }
}

impl AssetListWithExtendedRequest {
    pub fn new(asset_list: Vec<Vec<String>>, extended: Option<bool>) -> Self {
        Self {
            asset_list,
            extended,
        }
    }
}

impl DrepIdBulkRequest {
    pub fn new(drep_ids: Vec<String>) -> Self {
        Self { drep_ids }
    }
}

impl UtxoRefsWithExtendedRequest {
    pub fn new(utxo_refs: Vec<String>, extended: Option<bool>) -> Self {
        Self {
            utxo_refs,
            extended,
        }
    }
}

impl OgmiosRequest {
    pub fn new(method: String) -> Self {
        Self {
            jsonrpc: "2.0".to_string(),
            method,
            params: None,
        }
    }

    pub fn with_params(method: String, params: serde_json::Value) -> Self {
        Self {
            jsonrpc: "2.0".to_string(),
            method,
            params: Some(params),
        }
    }
}
koios_sdk/models/requests.rs

koios_sdk/models/
requests.rs
