"""
A block with its relevant data.
"""
type Block {
	"""
	The block hash.
	"""
	hash: HexEncoded!
	"""
	The block height.
	"""
	height: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
	"""
	The UNIX timestamp.
	"""
	timestamp: Int!
	"""
	The hex-encoded block author.
	"""
	author: HexEncoded
	"""
	The hex-encoded ledger parameters for this block.
	"""
	ledgerParameters: HexEncoded!
	"""
	The parent of this block.
	"""
	parent: Block
	"""
	The transactions within this block.
	"""
	transactions: [Transaction!]!
	"""
	The system parameters (governance) at this block height.
	"""
	systemParameters: SystemParameters!
}

"""
Either a block hash or a block height.
"""
input BlockOffset @oneOf {
	"""
	A hex-encoded block hash.
	"""
	hash: HexEncoded
	"""
	A block height.
	"""
	height: Int
}

scalar CardanoRewardAddress

type CollapsedMerkleTree {
	"""
	The zswap state start index.
	"""
	startIndex: Int!
	"""
	The zswap state end index.
	"""
	endIndex: Int!
	"""
	The hex-encoded value.
	"""
	update: HexEncoded!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
}

"""
Committee member for an epoch.
"""
type CommitteeMember {
	epochNo: Int!
	position: Int!
	sidechainPubkeyHex: String!
	expectedSlots: Int!
	auraPubkeyHex: String
	poolIdHex: String
	spoSkHex: String
}

"""
A contract action.
"""
interface ContractAction {
	address: HexEncoded!
	state: HexEncoded!
	zswapState: HexEncoded!
	transaction: Transaction!
	unshieldedBalances: [ContractBalance!]!
}

"""
Either a block offset or a transaction offset.
"""
input ContractActionOffset @oneOf {
	"""
	Either a block hash or a block height.
	"""
	blockOffset: BlockOffset
	"""
	Either a transaction hash or a transaction identifier.
	"""
	transactionOffset: TransactionOffset
}

"""
Represents a token balance held by a contract.
This type is exposed through the GraphQL API to allow clients to query
unshielded token balances for any contract action (Deploy, Call, Update).
"""
type ContractBalance {
	"""
	Hex-encoded token type identifier.
	"""
	tokenType: HexEncoded!
	"""
	Balance amount as string to support larger integer values (up to 16 bytes).
	"""
	amount: String!
}

"""
A contract call.
"""
type ContractCall implements ContractAction {
	"""
	The hex-encoded serialized address.
	"""
	address: HexEncoded!
	"""
	The hex-encoded serialized state.
	"""
	state: HexEncoded!
	"""
	The hex-encoded serialized contract-specific zswap state.
	"""
	zswapState: HexEncoded!
	"""
	The entry point.
	"""
	entryPoint: String!
	"""
	Transaction for this contract call.
	"""
	transaction: Transaction!
	"""
	Contract deploy for this contract call.
	"""
	deploy: ContractDeploy!
	"""
	Unshielded token balances held by this contract.
	"""
	unshieldedBalances: [ContractBalance!]!
}

"""
A contract deployment.
"""
type ContractDeploy implements ContractAction {
	"""
	The hex-encoded serialized address.
	"""
	address: HexEncoded!
	"""
	The hex-encoded serialized state.
	"""
	state: HexEncoded!
	"""
	The hex-encoded serialized contract-specific zswap state.
	"""
	zswapState: HexEncoded!
	"""
	Transaction for this contract deploy.
	"""
	transaction: Transaction!
	"""
	Unshielded token balances held by this contract.
	"""
	unshieldedBalances: [ContractBalance!]!
}

"""
A contract update.
"""
type ContractUpdate implements ContractAction {
	"""
	The hex-encoded serialized address.
	"""
	address: HexEncoded!
	"""
	The hex-encoded serialized state.
	"""
	state: HexEncoded!
	"""
	The hex-encoded serialized contract-specific zswap state.
	"""
	zswapState: HexEncoded!
	"""
	Transaction for this contract update.
	"""
	transaction: Transaction!
	"""
	Unshielded token balances held by this contract after the update.
	"""
	unshieldedBalances: [ContractBalance!]!
}

"""
The D-parameter controlling validator committee composition.
"""
type DParameter {
	"""
	Number of permissioned candidates.
	"""
	numPermissionedCandidates: Int!
	"""
	Number of registered candidates.
	"""
	numRegisteredCandidates: Int!
}

"""
D-parameter change record for history queries.
"""
type DParameterChange {
	"""
	The block height where this parameter became effective.
	"""
	blockHeight: Int!
	"""
	The hex-encoded block hash where this parameter became effective.
	"""
	blockHash: HexEncoded!
	"""
	The UNIX timestamp when this parameter became effective.
	"""
	timestamp: Int!
	"""
	Number of permissioned candidates.
	"""
	numPermissionedCandidates: Int!
	"""
	Number of registered candidates.
	"""
	numRegisteredCandidates: Int!
}

scalar DustAddress

type DustGenerationDtimeUpdate implements DustLedgerEvent {
	"""
	The ID of this dust ledger event.
	"""
	id: Int!
	"""
	The hex-encoded serialized event.
	"""
	raw: HexEncoded!
	"""
	The maximum ID of all dust ledger events.
	"""
	maxId: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
}

"""
DUST generation status for a specific Cardano reward address.
"""
type DustGenerationStatus {
	"""
	The Bech32-encoded Cardano reward address (e.g., stake_test1... or stake1...).
	"""
	cardanoRewardAddress: CardanoRewardAddress!
	"""
	The Bech32m-encoded associated DUST address if registered.
	"""
	dustAddress: DustAddress
	"""
	Whether this reward address is registered.
	"""
	registered: Boolean!
	"""
	NIGHT balance backing generation in STAR.
	"""
	nightBalance: String!
	"""
	DUST generation rate in SPECK per second.
	"""
	generationRate: String!
	"""
	Maximum DUST capacity in SPECK.
	"""
	maxCapacity: String!
	"""
	Current generated DUST capacity in SPECK.
	"""
	currentCapacity: String!
	"""
	Cardano UTXO transaction hash for update/unregister operations.
	"""
	utxoTxHash: HexEncoded
	"""
	Cardano UTXO output index for update/unregister operations.
	"""
	utxoOutputIndex: Int
}

type DustInitialUtxo implements DustLedgerEvent {
	"""
	The ID of this dust ledger event.
	"""
	id: Int!
	"""
	The hex-encoded serialized event.
	"""
	raw: HexEncoded!
	"""
	The maximum ID of all dust ledger events.
	"""
	maxId: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
	"""
	The dust output.
	"""
	output: DustOutput!
}

"""
A dust related ledger event.
"""
interface DustLedgerEvent {
	id: Int!
	raw: HexEncoded!
	maxId: Int!
	protocolVersion: Int!
}

"""
A dust output.
"""
type DustOutput {
	"""
	The hex-encoded 32-byte nonce.
	"""
	nonce: HexEncoded!
}

type DustSpendProcessed implements DustLedgerEvent {
	"""
	The ID of this dust ledger event.
	"""
	id: Int!
	"""
	The hex-encoded serialized event.
	"""
	raw: HexEncoded!
	"""
	The maximum ID of all dust ledger events.
	"""
	maxId: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
}

"""
Current epoch information.
"""
type EpochInfo {
	epochNo: Int!
	durationSeconds: Int!
	elapsedSeconds: Int!
}

"""
SPO performance for an epoch.
"""
type EpochPerf {
	epochNo: Int!
	spoSkHex: String!
	produced: Int!
	expected: Int!
	identityLabel: String
	stakeSnapshot: String
	poolIdHex: String
	validatorClass: String
}

"""
First valid epoch for an SPO identity.
"""
type FirstValidEpoch {
	idKey: String!
	firstValidEpoch: Int!
}

scalar HexEncoded

type Mutation {
	"""
	Connect the wallet with the given viewing key and return a session ID.
	"""
	connect(viewingKey: ViewingKey!): HexEncoded!
	"""
	Disconnect the wallet with the given session ID.
	"""
	disconnect(sessionId: HexEncoded!): Unit!
}

type ParamChange implements DustLedgerEvent {
	"""
	The ID of this dust ledger event.
	"""
	id: Int!
	"""
	The hex-encoded serialized event.
	"""
	raw: HexEncoded!
	"""
	The maximum ID of all dust ledger events.
	"""
	maxId: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
}

"""
Pool metadata from Cardano.
"""
type PoolMetadata {
	poolIdHex: String!
	hexId: String
	name: String
	ticker: String
	homepageUrl: String
	logoUrl: String
}

"""
Presence event for an SPO in an epoch.
"""
type PresenceEvent {
	epochNo: Int!
	idKey: String!
	source: String!
	status: String
}

type Query {
	"""
	Find a block for the given optional offset; if not present, the latest block is returned.
	"""
	block(offset: BlockOffset): Block
	"""
	Find transactions for the given offset.
	"""
	transactions(offset: TransactionOffset!): [Transaction!]!
	"""
	Find a contract action for the given address and optional offset.
	"""
	contractAction(address: HexEncoded!, offset: ContractActionOffset): ContractAction
	"""
	Get DUST generation status for specific Cardano reward addresses.
	"""
	dustGenerationStatus(cardanoRewardAddresses: [CardanoRewardAddress!]!): [DustGenerationStatus!]!
	"""
	Get the full history of D-parameter changes for governance auditability.
	"""
	dParameterHistory: [DParameterChange!]!
	"""
	Get the full history of Terms and Conditions changes for governance auditability.
	"""
	termsAndConditionsHistory: [TermsAndConditionsChange!]!
	"""
	List SPO identities with pagination.
	"""
	spoIdentities(limit: Int, offset: Int): [SpoIdentity!]!
	"""
	Get SPO identity by pool ID.
	"""
	spoIdentityByPoolId(poolIdHex: String!): SpoIdentity
	"""
	Get total count of SPOs.
	"""
	spoCount: Int
	"""
	Get pool metadata by pool ID.
	"""
	poolMetadata(poolIdHex: String!): PoolMetadata
	"""
	List pool metadata with pagination.
	"""
	poolMetadataList(limit: Int, offset: Int, withNameOnly: Boolean): [PoolMetadata!]!
	"""
	Get SPO with metadata by pool ID.
	"""
	spoByPoolId(poolIdHex: String!): Spo
	"""
	List SPOs with optional search.
	"""
	spoList(limit: Int, offset: Int, search: String): [Spo!]!
	"""
	Get composite SPO data (identity + metadata + performance).
	"""
	spoCompositeByPoolId(poolIdHex: String!): SpoComposite
	"""
	Get SPO identifiers ordered by performance.
	"""
	stakePoolOperators(limit: Int): [String!]!
	"""
	Get latest SPO performance entries.
	"""
	spoPerformanceLatest(limit: Int, offset: Int): [EpochPerf!]!
	"""
	Get SPO performance by SPO key.
	"""
	spoPerformanceBySpoSk(spoSkHex: String!, limit: Int, offset: Int): [EpochPerf!]!
	"""
	Get epoch performance for all SPOs.
	"""
	epochPerformance(epoch: Int!, limit: Int, offset: Int): [EpochPerf!]!
	"""
	Get current epoch information.
	"""
	currentEpochInfo: EpochInfo
	"""
	Get epoch utilization (produced/expected ratio).
	"""
	epochUtilization(epoch: Int!): Float
	"""
	Get committee membership for an epoch.
	"""
	committee(epoch: Int!): [CommitteeMember!]!
	"""
	Get cumulative registration totals for an epoch range.
	"""
	registeredTotalsSeries(fromEpoch: Int!, toEpoch: Int!): [RegisteredTotals!]!
	"""
	Get registration statistics for an epoch range.
	"""
	registeredSpoSeries(fromEpoch: Int!, toEpoch: Int!): [RegisteredStat!]!
	"""
	Get raw presence events for an epoch range.
	"""
	registeredPresence(fromEpoch: Int!, toEpoch: Int!): [PresenceEvent!]!
	"""
	Get first valid epoch for each SPO identity.
	"""
	registeredFirstValidEpochs(uptoEpoch: Int): [FirstValidEpoch!]!
	"""
	Get stake distribution with search and ordering.
	"""
	stakeDistribution(limit: Int, offset: Int, search: String, orderByStakeDesc: Boolean): [StakeShare!]!
}

"""
Registration statistics for an epoch.
"""
type RegisteredStat {
	epochNo: Int!
	federatedValidCount: Int!
	federatedInvalidCount: Int!
	registeredValidCount: Int!
	registeredInvalidCount: Int!
	dparam: Float
}

"""
Cumulative registration totals for an epoch.
"""
type RegisteredTotals {
	epochNo: Int!
	totalRegistered: Int!
	newlyRegistered: Int!
}

"""
A regular Midnight transaction.
"""
type RegularTransaction implements Transaction {
	"""
	The transaction ID.
	"""
	id: Int!
	"""
	The hex-encoded transaction hash.
	"""
	hash: HexEncoded!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
	"""
	The hex-encoded serialized transaction content.
	"""
	raw: HexEncoded!
	"""
	The result of applying this transaction to the ledger state.
	"""
	transactionResult: TransactionResult!
	"""
	The hex-encoded serialized transaction identifiers.
	"""
	identifiers: [HexEncoded!]!
	"""
	The hex-encoded serialized merkle-tree root.
	"""
	merkleTreeRoot: HexEncoded!
	"""
	The zswap state start index.
	"""
	startIndex: Int!
	"""
	The zswap state end index.
	"""
	endIndex: Int!
	"""
	Fee information for this transaction.
	"""
	fees: TransactionFees!
	"""
	The block for this transaction.
	"""
	block: Block!
	"""
	The contract actions for this transaction.
	"""
	contractActions: [ContractAction!]!
	"""
	Unshielded UTXOs created by this transaction.
	"""
	unshieldedCreatedOutputs: [UnshieldedUtxo!]!
	"""
	Unshielded UTXOs spent (consumed) by this transaction.
	"""
	unshieldedSpentOutputs: [UnshieldedUtxo!]!
	"""
	Zswap ledger events of this transaction.
	"""
	zswapLedgerEvents: [ZswapLedgerEvent!]!
	"""
	Dust ledger events of this transaction.
	"""
	dustLedgerEvents: [DustLedgerEvent!]!
}

"""
A transaction relevant for the subscribing wallet and an optional collapsed merkle tree.
"""
type RelevantTransaction {
	"""
	A transaction relevant for the subscribing wallet.
	"""
	transaction: RegularTransaction!
	"""
	An optional collapsed merkle tree.
	"""
	collapsedMerkleTree: CollapsedMerkleTree
}

"""
One of many segments for a partially successful transaction result showing success for some
segment.
"""
type Segment {
	"""
	Segment ID.
	"""
	id: Int!
	"""
	Successful or not.
	"""
	success: Boolean!
}

"""
An event of the shielded transactions subscription.
"""
union ShieldedTransactionsEvent = RelevantTransaction | ShieldedTransactionsProgress

"""
Information about the shielded transactions indexing progress.
"""
type ShieldedTransactionsProgress {
	"""
	The highest zswap state end index (see `endIndex` of `Transaction`) of all transactions. It
	represents the known state of the blockchain. A value of zero (completely unlikely) means
	that no shielded transactions have been indexed yet.
	"""
	highestEndIndex: Int!
	"""
	The highest zswap state end index (see `endIndex` of `Transaction`) of all transactions
	checked for relevance. Initially less than and eventually (when some wallet has been fully
	indexed) equal to `highest_end_index`. A value of zero (very unlikely) means that no wallet
	has subscribed before and indexing for the subscribing wallet has not yet started.
	"""
	highestCheckedEndIndex: Int!
	"""
	The highest zswap state end index (see `endIndex` of `Transaction`) of all relevant
	transactions for the subscribing wallet. Usually less than `highest_checked_end_index`
	unless the latest checked transaction is relevant for the subscribing wallet. A value of
	zero means that no relevant transactions have been indexed for the subscribing wallet.
	"""
	highestRelevantEndIndex: Int!
}

"""
SPO with optional metadata.
"""
type Spo {
	poolIdHex: String!
	validatorClass: String!
	sidechainPubkeyHex: String!
	auraPubkeyHex: String
	name: String
	ticker: String
	homepageUrl: String
	logoUrl: String
}

"""
Composite SPO data (identity + metadata + performance).
"""
type SpoComposite {
	identity: SpoIdentity
	metadata: PoolMetadata
	performance: [EpochPerf!]!
}

"""
SPO identity information.
"""
type SpoIdentity {
	poolIdHex: String!
	mainchainPubkeyHex: String!
	sidechainPubkeyHex: String!
	auraPubkeyHex: String
	validatorClass: String!
}

"""
Stake share information for an SPO.

Values are sourced from mainchain pool data (e.g., Blockfrost) and keyed by Cardano pool_id.
"""
type StakeShare {
	"""
	Cardano pool ID (56-character hex string).
	"""
	poolIdHex: String!
	"""
	Pool name from metadata.
	"""
	name: String
	"""
	Pool ticker from metadata.
	"""
	ticker: String
	"""
	Pool homepage URL from metadata.
	"""
	homepageUrl: String
	"""
	Pool logo URL from metadata.
	"""
	logoUrl: String
	"""
	Current live stake in lovelace.
	"""
	liveStake: String
	"""
	Current active stake in lovelace.
	"""
	activeStake: String
	"""
	Number of live delegators.
	"""
	liveDelegators: Int
	"""
	Saturation ratio (0.0 to 1.0+).
	"""
	liveSaturation: Float
	"""
	Declared pledge in lovelace.
	"""
	declaredPledge: String
	"""
	Current live pledge in lovelace.
	"""
	livePledge: String
	"""
	Stake share as a fraction of total stake.
	"""
	stakeShare: Float
}

type Subscription {
	"""
	Subscribe to blocks starting at the given offset or at the latest block if the offset is
	omitted.
	"""
	blocks(offset: BlockOffset): Block!
	"""
	Subscribe to contract actions with the given address starting at the given offset or at the
	latest block if the offset is omitted.
	"""
	contractActions(address: HexEncoded!, offset: BlockOffset): ContractAction!
	"""
	Subscribe to dust ledger events starting at the given ID or at the very start if omitted.
	"""
	dustLedgerEvents(id: Int): DustLedgerEvent!
	"""
	Subscribe to shielded transaction events for the given session ID starting at the given
	index or at zero if omitted.
	"""
	shieldedTransactions(sessionId: HexEncoded!, index: Int): ShieldedTransactionsEvent!
	"""
	Subscribe unshielded transaction events for the given address and the given transaction ID
	or zero if omitted.
	"""
	unshieldedTransactions(address: UnshieldedAddress!, transactionId: Int): UnshieldedTransactionsEvent!
	"""
	Subscribe to zswap ledger events starting at the given ID or at the very start if omitted.
	"""
	zswapLedgerEvents(id: Int): ZswapLedgerEvent!
}

"""
System parameters at a specific block height.
"""
type SystemParameters {
	"""
	The D-parameter controlling validator committee composition.
	"""
	dParameter: DParameter!
	"""
	The current Terms and Conditions, if any have been set.
	"""
	termsAndConditions: TermsAndConditions
}

"""
A system Midnight transaction.
"""
type SystemTransaction implements Transaction {
	"""
	The transaction ID.
	"""
	id: Int!
	"""
	The hex-encoded transaction hash.
	"""
	hash: HexEncoded!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
	"""
	The hex-encoded serialized transaction content.
	"""
	raw: HexEncoded!
	"""
	The block for this transaction.
	"""
	block: Block!
	"""
	The contract actions for this transaction.
	"""
	contractActions: [ContractAction!]!
	"""
	Unshielded UTXOs created by this transaction.
	"""
	unshieldedCreatedOutputs: [UnshieldedUtxo!]!
	"""
	Unshielded UTXOs spent (consumed) by this transaction.
	"""
	unshieldedSpentOutputs: [UnshieldedUtxo!]!
	"""
	Zswap ledger events of this transaction.
	"""
	zswapLedgerEvents: [ZswapLedgerEvent!]!
	"""
	Dust ledger events of this transaction.
	"""
	dustLedgerEvents: [DustLedgerEvent!]!
}

"""
Terms and Conditions agreement.
"""
type TermsAndConditions {
	"""
	The hex-encoded hash of the Terms and Conditions document.
	"""
	hash: HexEncoded!
	"""
	The URL where the Terms and Conditions can be found.
	"""
	url: String!
}

"""
Terms and Conditions change record for history queries.
"""
type TermsAndConditionsChange {
	"""
	The block height where this T&C version became effective.
	"""
	blockHeight: Int!
	"""
	The hex-encoded block hash where this T&C version became effective.
	"""
	blockHash: HexEncoded!
	"""
	The UNIX timestamp when this T&C version became effective.
	"""
	timestamp: Int!
	"""
	The hex-encoded hash of the Terms and Conditions document.
	"""
	hash: HexEncoded!
	"""
	The URL where the Terms and Conditions can be found.
	"""
	url: String!
}

"""
A Midnight transaction.
"""
interface Transaction {
	id: Int!
	hash: HexEncoded!
	protocolVersion: Int!
	raw: HexEncoded!
	block: Block!
	contractActions: [ContractAction!]!
	unshieldedCreatedOutputs: [UnshieldedUtxo!]!
	unshieldedSpentOutputs: [UnshieldedUtxo!]!
	zswapLedgerEvents: [ZswapLedgerEvent!]!
	dustLedgerEvents: [DustLedgerEvent!]!
}

"""
Fees information for a transaction, including both paid and estimated fees.
"""
type TransactionFees {
	"""
	The actual fees paid for this transaction in DUST.
	"""
	paidFees: String!
	"""
	The estimated fees that was calculated for this transaction in DUST.
	"""
	estimatedFees: String!
}

"""
Either a transaction hash or a transaction identifier.
"""
input TransactionOffset @oneOf {
	"""
	A hex-encoded transaction hash.
	"""
	hash: HexEncoded
	"""
	A hex-encoded transaction identifier.
	"""
	identifier: HexEncoded
}

"""
The result of applying a transaction to the ledger state. In case of a partial success (status),
there will be segments.
"""
type TransactionResult {
	status: TransactionResultStatus!
	segments: [Segment!]
}

"""
The status of the transaction result: success, partial success or failure.
"""
enum TransactionResultStatus {
	SUCCESS
	PARTIAL_SUCCESS
	FAILURE
}

scalar Unit

scalar UnshieldedAddress

"""
A transaction that created and/or spent UTXOs alongside these and other information.
"""
type UnshieldedTransaction {
	"""
	The transaction that created and/or spent UTXOs.
	"""
	transaction: Transaction!
	"""
	UTXOs created in the above transaction, possibly empty.
	"""
	createdUtxos: [UnshieldedUtxo!]!
	"""
	UTXOs spent in the above transaction, possibly empty.
	"""
	spentUtxos: [UnshieldedUtxo!]!
}

"""
An event of the unshielded transactions subscription.
"""
union UnshieldedTransactionsEvent = UnshieldedTransaction | UnshieldedTransactionsProgress

"""
Information about the unshielded indexing progress.
"""
type UnshieldedTransactionsProgress {
	"""
	The highest transaction ID of all currently known transactions for a subscribed address.
	"""
	highestTransactionId: Int!
}

"""
Represents an unshielded UTXO.
"""
type UnshieldedUtxo {
	"""
	Owner Bech32m-encoded address.
	"""
	owner: UnshieldedAddress!
	"""
	Token hex-encoded serialized token type.
	"""
	tokenType: HexEncoded!
	"""
	UTXO value (quantity) as a string to support u128.
	"""
	value: String!
	"""
	The hex-encoded serialized intent hash.
	"""
	intentHash: HexEncoded!
	"""
	Index of this output within its creating transaction.
	"""
	outputIndex: Int!
	"""
	The creation time in seconds.
	"""
	ctime: Int
	"""
	The hex-encoded initial nonce for DUST generation tracking.
	"""
	initialNonce: HexEncoded!
	"""
	Whether this UTXO is registered for DUST generation.
	"""
	registeredForDustGeneration: Boolean!
	"""
	Transaction that created this UTXO.
	"""
	createdAtTransaction: Transaction!
	"""
	Transaction that spent this UTXO.
	"""
	spentAtTransaction: Transaction
}

scalar ViewingKey

"""
A zswap related ledger event.
"""
type ZswapLedgerEvent {
	"""
	The ID of this zswap ledger event.
	"""
	id: Int!
	"""
	The hex-encoded serialized event.
	"""
	raw: HexEncoded!
	"""
	The maximum ID of all zswap ledger events.
	"""
	maxId: Int!
	"""
	The protocol version.
	"""
	protocolVersion: Int!
}

"""
Directs the executor to include this field or fragment only when the `if` argument is true.
"""
directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
"""
Indicates that an Input Object is a OneOf Input Object (and thus requires exactly one of its field be provided)
"""
directive @oneOf on INPUT_OBJECT
"""
Directs the executor to skip this field or fragment when the `if` argument is true.
"""
directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
schema {
	query: Query
	mutation: Mutation
	subscription: Subscription
}