8b4611f9bb
This change is required by the DCI to properly detect potential address changes (retriggers) on packed storage slots.
506 lines
22 KiB
Rust
506 lines
22 KiB
Rust
// @generated
|
|
// This file contains the proto definitions for Substreams common to all integrations.
|
|
|
|
/// A struct describing a block.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct Block {
|
|
/// The blocks hash.
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub hash: ::prost::alloc::vec::Vec<u8>,
|
|
/// The parent blocks hash.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub parent_hash: ::prost::alloc::vec::Vec<u8>,
|
|
/// The block number.
|
|
#[prost(uint64, tag="3")]
|
|
pub number: u64,
|
|
/// The block timestamp.
|
|
#[prost(uint64, tag="4")]
|
|
pub ts: u64,
|
|
}
|
|
/// A struct describing a transaction.
|
|
#[derive(Eq, Hash)]
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct Transaction {
|
|
/// The transaction hash.
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub hash: ::prost::alloc::vec::Vec<u8>,
|
|
/// The sender of the transaction.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub from: ::prost::alloc::vec::Vec<u8>,
|
|
/// The receiver of the transaction.
|
|
#[prost(bytes="vec", tag="3")]
|
|
pub to: ::prost::alloc::vec::Vec<u8>,
|
|
/// The transactions index within the block.
|
|
/// TODO: should this be uint32? to match the type from the native substream type?
|
|
#[prost(uint64, tag="4")]
|
|
pub index: u64,
|
|
}
|
|
/// A custom struct representing an arbitrary attribute of a protocol component.
|
|
/// This is mainly used by the native integration to track the necessary information about the protocol.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct Attribute {
|
|
/// The name of the attribute.
|
|
#[prost(string, tag="1")]
|
|
pub name: ::prost::alloc::string::String,
|
|
/// The value of the attribute.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub value: ::prost::alloc::vec::Vec<u8>,
|
|
/// The type of change the attribute underwent.
|
|
#[prost(enumeration="ChangeType", tag="3")]
|
|
pub change: i32,
|
|
}
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct ProtocolType {
|
|
#[prost(string, tag="1")]
|
|
pub name: ::prost::alloc::string::String,
|
|
#[prost(enumeration="FinancialType", tag="2")]
|
|
pub financial_type: i32,
|
|
#[prost(message, repeated, tag="3")]
|
|
pub attribute_schema: ::prost::alloc::vec::Vec<Attribute>,
|
|
#[prost(enumeration="ImplementationType", tag="4")]
|
|
pub implementation_type: i32,
|
|
}
|
|
/// A struct describing a part of the protocol.
|
|
/// Note: For example this can be a UniswapV2 pair, that tracks the two ERC20 tokens used by the pair,
|
|
/// the component would represent a single contract. In case of VM integration, such component would
|
|
/// not need any attributes, because all the relevant info would be tracked via storage slots and balance changes.
|
|
/// It can also be a wrapping contract, like WETH, that has a constant price, but it allows swapping tokens.
|
|
/// This is why the name ProtocolComponent is used instead of "Pool" or "Pair".
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct ProtocolComponent {
|
|
/// A unique identifier for the component within the protocol.
|
|
/// Can be e.g. a stringified address or a string describing the trading pair.
|
|
#[prost(string, tag="1")]
|
|
pub id: ::prost::alloc::string::String,
|
|
/// Addresses of the ERC20 tokens used by the component.
|
|
#[prost(bytes="vec", repeated, tag="2")]
|
|
pub tokens: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
|
|
/// Addresses of the contracts used by the component.
|
|
/// Usually it is a single contract, but some protocols use multiple contracts.
|
|
#[prost(bytes="vec", repeated, tag="3")]
|
|
pub contracts: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
|
|
/// Static attributes of the component.
|
|
/// These attributes MUST be immutable. If it can ever change, it should be given as an EntityChanges for this component id.
|
|
/// The inner ChangeType of the attribute has to match the ChangeType of the ProtocolComponent.
|
|
#[prost(message, repeated, tag="4")]
|
|
pub static_att: ::prost::alloc::vec::Vec<Attribute>,
|
|
/// Type of change the component underwent.
|
|
#[prost(enumeration="ChangeType", tag="5")]
|
|
pub change: i32,
|
|
/// / Represents the functionality of the component.
|
|
#[prost(message, optional, tag="6")]
|
|
pub protocol_type: ::core::option::Option<ProtocolType>,
|
|
}
|
|
/// A struct for following the changes of Total Value Locked (TVL) of a protocol component.
|
|
/// Note that if a ProtocolComponent contains multiple contracts, the TVL is tracked for the component as a whole.
|
|
/// E.g. for UniswapV2 pair WETH/USDC, this tracks the USDC and WETH balance of the pair contract.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BalanceChange {
|
|
/// The address of the ERC20 token whose balance changed.
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub token: ::prost::alloc::vec::Vec<u8>,
|
|
/// The new balance of the token. Note: it must be a big endian encoded int.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub balance: ::prost::alloc::vec::Vec<u8>,
|
|
/// The id of the component whose TVL is tracked. Note: This MUST be utf8 encoded.
|
|
/// If the protocol component includes multiple contracts, the balance change must be aggregated to reflect how much tokens can be traded.
|
|
#[prost(bytes="vec", tag="3")]
|
|
pub component_id: ::prost::alloc::vec::Vec<u8>,
|
|
}
|
|
// Native entities
|
|
|
|
/// A component is a set of attributes that are associated with a custom entity.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct EntityChanges {
|
|
/// A unique identifier of the entity within the protocol.
|
|
#[prost(string, tag="1")]
|
|
pub component_id: ::prost::alloc::string::String,
|
|
/// The set of attributes that are associated with the entity.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub attributes: ::prost::alloc::vec::Vec<Attribute>,
|
|
}
|
|
// VM entities
|
|
|
|
/// A key value entry into contract storage.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct ContractSlot {
|
|
/// A contract's storage slot.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub slot: ::prost::alloc::vec::Vec<u8>,
|
|
/// The new value for this storage slot.
|
|
#[prost(bytes="vec", tag="3")]
|
|
pub value: ::prost::alloc::vec::Vec<u8>,
|
|
/// The old value of this storage slot
|
|
#[prost(bytes="vec", tag="4")]
|
|
pub previous_value: ::prost::alloc::vec::Vec<u8>,
|
|
}
|
|
/// A struct for following the token balance changes for a contract.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct AccountBalanceChange {
|
|
/// The address of the ERC20 token whose balance changed.
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub token: ::prost::alloc::vec::Vec<u8>,
|
|
/// The new balance of the token. Note: it must be a big endian encoded int.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub balance: ::prost::alloc::vec::Vec<u8>,
|
|
}
|
|
/// Changes made to a single contract's state.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct ContractChange {
|
|
/// The contract's address
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub address: ::prost::alloc::vec::Vec<u8>,
|
|
/// The new balance of the contract, empty bytes indicates no change.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub balance: ::prost::alloc::vec::Vec<u8>,
|
|
/// The new code of the contract, empty bytes indicates no change.
|
|
#[prost(bytes="vec", tag="3")]
|
|
pub code: ::prost::alloc::vec::Vec<u8>,
|
|
/// The changes to this contract's slots, empty sequence indicates no change.
|
|
#[prost(message, repeated, tag="4")]
|
|
pub slots: ::prost::alloc::vec::Vec<ContractSlot>,
|
|
/// Whether this is an update, a creation or a deletion.
|
|
#[prost(enumeration="ChangeType", tag="5")]
|
|
pub change: i32,
|
|
/// The new ERC20 balances of the contract.
|
|
#[prost(message, repeated, tag="6")]
|
|
pub token_balances: ::prost::alloc::vec::Vec<AccountBalanceChange>,
|
|
}
|
|
// DCI entities
|
|
|
|
/// An entrypoint to be used for DCI analysis
|
|
#[derive(Eq, Hash)]
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct EntryPoint {
|
|
/// The entrypoint id. Recommended to use 'target:signature'.
|
|
#[prost(string, tag="1")]
|
|
pub id: ::prost::alloc::string::String,
|
|
/// The target contract to analyse this entrypoint on.
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub target: ::prost::alloc::vec::Vec<u8>,
|
|
/// The signature of the function to analyse.
|
|
#[prost(string, tag="3")]
|
|
pub signature: ::prost::alloc::string::String,
|
|
/// The id of the component that uses this entrypoint.
|
|
#[prost(string, tag="4")]
|
|
pub component_id: ::prost::alloc::string::String,
|
|
}
|
|
/// Parameters to trace the entrypoint
|
|
#[derive(Eq, Hash)]
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct EntryPointParams {
|
|
/// The entrypoint id.
|
|
#[prost(string, tag="1")]
|
|
pub entrypoint_id: ::prost::alloc::string::String,
|
|
/// \[optional\] The component that uses these entrypoint parameters. Currently used for debugging purposes only.
|
|
#[prost(string, optional, tag="2")]
|
|
pub component_id: ::core::option::Option<::prost::alloc::string::String>,
|
|
/// The strategy and its corresponding data
|
|
#[prost(oneof="entry_point_params::TraceData", tags="3")]
|
|
pub trace_data: ::core::option::Option<entry_point_params::TraceData>,
|
|
}
|
|
/// Nested message and enum types in `EntryPointParams`.
|
|
pub mod entry_point_params {
|
|
/// The strategy and its corresponding data
|
|
#[derive(Eq, Hash)]
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Oneof)]
|
|
pub enum TraceData {
|
|
/// Add more strategies here
|
|
#[prost(message, tag="3")]
|
|
Rpc(super::RpcTraceData),
|
|
}
|
|
}
|
|
/// RPC tracing strategy with its data
|
|
#[derive(Eq, Hash)]
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct RpcTraceData {
|
|
/// \[optional\] The caller to be used for the trace. If none is provided a chain default will be used.
|
|
#[prost(bytes="vec", optional, tag="1")]
|
|
pub caller: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
|
|
/// The calldata to be used for the trace
|
|
#[prost(bytes="vec", tag="2")]
|
|
pub calldata: ::prost::alloc::vec::Vec<u8>,
|
|
}
|
|
/// A contract and associated storage changes
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct StorageChanges {
|
|
/// The contract's address
|
|
#[prost(bytes="vec", tag="1")]
|
|
pub address: ::prost::alloc::vec::Vec<u8>,
|
|
/// The contract's storage changes
|
|
#[prost(message, repeated, tag="2")]
|
|
pub slots: ::prost::alloc::vec::Vec<ContractSlot>,
|
|
}
|
|
// Aggregate entities
|
|
|
|
/// A set of changes aggregated by transaction.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct TransactionChanges {
|
|
/// The transaction instance that results in the changes.
|
|
#[prost(message, optional, tag="1")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
/// Contains the changes induced by the above transaction, aggregated on a per-contract basis.
|
|
/// Contains the contract changes induced by the above transaction, usually for tracking VM components.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub contract_changes: ::prost::alloc::vec::Vec<ContractChange>,
|
|
/// Contains the entity changes induced by the above transaction.
|
|
/// Usually for tracking native components or used for VM extensions (plugins).
|
|
#[prost(message, repeated, tag="3")]
|
|
pub entity_changes: ::prost::alloc::vec::Vec<EntityChanges>,
|
|
/// An array of newly added components.
|
|
#[prost(message, repeated, tag="4")]
|
|
pub component_changes: ::prost::alloc::vec::Vec<ProtocolComponent>,
|
|
/// An array of balance changes to components.
|
|
#[prost(message, repeated, tag="5")]
|
|
pub balance_changes: ::prost::alloc::vec::Vec<BalanceChange>,
|
|
/// An array of newly added entrypoints. Used for DCI enabled protocols.
|
|
#[prost(message, repeated, tag="6")]
|
|
pub entrypoints: ::prost::alloc::vec::Vec<EntryPoint>,
|
|
/// An array of entrypoint tracing parameteres. Used for DCI enabled protocols.
|
|
#[prost(message, repeated, tag="7")]
|
|
pub entrypoint_params: ::prost::alloc::vec::Vec<EntryPointParams>,
|
|
}
|
|
/// A set of storage changes aggregated by transaction.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct TransactionStorageChanges {
|
|
/// The transaction instance that results in the changes.
|
|
#[prost(message, optional, tag="1")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
/// Contains the storage changes induced by the above transaction.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub storage_changes: ::prost::alloc::vec::Vec<StorageChanges>,
|
|
}
|
|
/// A set of transaction changes within a single block.
|
|
/// This message must be the output of your substreams module.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BlockChanges {
|
|
/// The block for which these changes are collectively computed.
|
|
#[prost(message, optional, tag="1")]
|
|
pub block: ::core::option::Option<Block>,
|
|
/// The set of transaction changes observed in the specified block.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub changes: ::prost::alloc::vec::Vec<TransactionChanges>,
|
|
/// The set of all storage changes from the specified block. Intended as input for the Dynamic Contract Indexer.
|
|
/// Should be left empty for protocols that do not use the DCI.
|
|
#[prost(message, repeated, tag="3")]
|
|
pub storage_changes: ::prost::alloc::vec::Vec<TransactionStorageChanges>,
|
|
}
|
|
/// Enum to specify the type of a change.
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
|
|
#[repr(i32)]
|
|
pub enum ChangeType {
|
|
Unspecified = 0,
|
|
Update = 1,
|
|
Creation = 2,
|
|
Deletion = 3,
|
|
}
|
|
impl ChangeType {
|
|
/// String value of the enum field names used in the ProtoBuf definition.
|
|
///
|
|
/// The values are not transformed in any way and thus are considered stable
|
|
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
|
|
pub fn as_str_name(&self) -> &'static str {
|
|
match self {
|
|
ChangeType::Unspecified => "CHANGE_TYPE_UNSPECIFIED",
|
|
ChangeType::Update => "CHANGE_TYPE_UPDATE",
|
|
ChangeType::Creation => "CHANGE_TYPE_CREATION",
|
|
ChangeType::Deletion => "CHANGE_TYPE_DELETION",
|
|
}
|
|
}
|
|
/// Creates an enum from field names used in the ProtoBuf definition.
|
|
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
|
|
match value {
|
|
"CHANGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
|
|
"CHANGE_TYPE_UPDATE" => Some(Self::Update),
|
|
"CHANGE_TYPE_CREATION" => Some(Self::Creation),
|
|
"CHANGE_TYPE_DELETION" => Some(Self::Deletion),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
|
|
#[repr(i32)]
|
|
pub enum FinancialType {
|
|
Swap = 0,
|
|
Lend = 1,
|
|
Leverage = 2,
|
|
Psm = 3,
|
|
}
|
|
impl FinancialType {
|
|
/// String value of the enum field names used in the ProtoBuf definition.
|
|
///
|
|
/// The values are not transformed in any way and thus are considered stable
|
|
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
|
|
pub fn as_str_name(&self) -> &'static str {
|
|
match self {
|
|
FinancialType::Swap => "SWAP",
|
|
FinancialType::Lend => "LEND",
|
|
FinancialType::Leverage => "LEVERAGE",
|
|
FinancialType::Psm => "PSM",
|
|
}
|
|
}
|
|
/// Creates an enum from field names used in the ProtoBuf definition.
|
|
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
|
|
match value {
|
|
"SWAP" => Some(Self::Swap),
|
|
"LEND" => Some(Self::Lend),
|
|
"LEVERAGE" => Some(Self::Leverage),
|
|
"PSM" => Some(Self::Psm),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
|
|
#[repr(i32)]
|
|
pub enum ImplementationType {
|
|
Vm = 0,
|
|
Custom = 1,
|
|
}
|
|
impl ImplementationType {
|
|
/// String value of the enum field names used in the ProtoBuf definition.
|
|
///
|
|
/// The values are not transformed in any way and thus are considered stable
|
|
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
|
|
pub fn as_str_name(&self) -> &'static str {
|
|
match self {
|
|
ImplementationType::Vm => "VM",
|
|
ImplementationType::Custom => "CUSTOM",
|
|
}
|
|
}
|
|
/// Creates an enum from field names used in the ProtoBuf definition.
|
|
pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
|
|
match value {
|
|
"VM" => Some(Self::Vm),
|
|
"CUSTOM" => Some(Self::Custom),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
// WARNING: DEPRECATED. Please use common.proto's TransactionChanges and BlockChanges instead.
|
|
// This file contains the definition for the native integration of Substreams.
|
|
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct TransactionEntityChanges {
|
|
#[prost(message, optional, tag="1")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
#[prost(message, repeated, tag="2")]
|
|
pub entity_changes: ::prost::alloc::vec::Vec<EntityChanges>,
|
|
/// An array of newly added components.
|
|
#[prost(message, repeated, tag="3")]
|
|
pub component_changes: ::prost::alloc::vec::Vec<ProtocolComponent>,
|
|
/// An array of balance changes to components.
|
|
#[prost(message, repeated, tag="4")]
|
|
pub balance_changes: ::prost::alloc::vec::Vec<BalanceChange>,
|
|
}
|
|
/// A set of transaction changes within a single block.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BlockEntityChanges {
|
|
/// The block for which these changes are collectively computed.
|
|
#[prost(message, optional, tag="1")]
|
|
pub block: ::core::option::Option<Block>,
|
|
/// The set of transaction changes observed in the specified block.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub changes: ::prost::alloc::vec::Vec<TransactionEntityChanges>,
|
|
}
|
|
/// A message containing relative balance changes.
|
|
///
|
|
/// Used to track token balances of protocol components in case they are only
|
|
/// available as relative values within a block.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BalanceDelta {
|
|
/// The ordinal of the balance change. Must be unique & deterministic over all balances
|
|
/// changes within a block.
|
|
#[prost(uint64, tag="1")]
|
|
pub ord: u64,
|
|
/// The tx hash of the transaction that caused the balance change.
|
|
#[prost(message, optional, tag="2")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
/// The address of the ERC20 token whose balance changed.
|
|
#[prost(bytes="vec", tag="3")]
|
|
pub token: ::prost::alloc::vec::Vec<u8>,
|
|
/// The delta balance of the token.
|
|
#[prost(bytes="vec", tag="4")]
|
|
pub delta: ::prost::alloc::vec::Vec<u8>,
|
|
/// The id of the component whose TVL is tracked.
|
|
/// If the protocol component includes multiple contracts, the balance change must be
|
|
/// aggregated to reflect how much tokens can be traded.
|
|
#[prost(bytes="vec", tag="5")]
|
|
pub component_id: ::prost::alloc::vec::Vec<u8>,
|
|
}
|
|
/// A set of balances deltas, usually a group of changes within a single block.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BlockBalanceDeltas {
|
|
#[prost(message, repeated, tag="1")]
|
|
pub balance_deltas: ::prost::alloc::vec::Vec<BalanceDelta>,
|
|
}
|
|
/// A message containing protocol components that were created by a single tx.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct TransactionProtocolComponents {
|
|
#[prost(message, optional, tag="1")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
#[prost(message, repeated, tag="2")]
|
|
pub components: ::prost::alloc::vec::Vec<ProtocolComponent>,
|
|
}
|
|
/// All protocol components that were created within a block with their corresponding tx.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BlockTransactionProtocolComponents {
|
|
#[prost(message, repeated, tag="1")]
|
|
pub tx_components: ::prost::alloc::vec::Vec<TransactionProtocolComponents>,
|
|
}
|
|
// WARNING: DEPRECATED. Please use common.proto's TransactionChanges and BlockChanges instead.
|
|
// This file contains proto definitions specific to the VM integration.
|
|
|
|
/// A set of changes aggregated by transaction.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct TransactionContractChanges {
|
|
/// The transaction instance that results in the changes.
|
|
#[prost(message, optional, tag="1")]
|
|
pub tx: ::core::option::Option<Transaction>,
|
|
/// Contains the changes induced by the above transaction, aggregated on a per-contract basis.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub contract_changes: ::prost::alloc::vec::Vec<ContractChange>,
|
|
/// An array of newly added components.
|
|
#[prost(message, repeated, tag="3")]
|
|
pub component_changes: ::prost::alloc::vec::Vec<ProtocolComponent>,
|
|
/// An array of balance changes to components.
|
|
#[prost(message, repeated, tag="4")]
|
|
pub balance_changes: ::prost::alloc::vec::Vec<BalanceChange>,
|
|
}
|
|
/// A set of transaction changes within a single block.
|
|
#[allow(clippy::derive_partial_eq_without_eq)]
|
|
#[derive(Clone, PartialEq, ::prost::Message)]
|
|
pub struct BlockContractChanges {
|
|
/// The block for which these changes are collectively computed.
|
|
#[prost(message, optional, tag="1")]
|
|
pub block: ::core::option::Option<Block>,
|
|
/// The set of transaction changes observed in the specified block.
|
|
#[prost(message, repeated, tag="2")]
|
|
pub changes: ::prost::alloc::vec::Vec<TransactionContractChanges>,
|
|
}
|
|
// @@protoc_insertion_point(module)
|