Files
tycho-protocol-sdk/substreams/ethereum-sfrax/src/pb/contract.v1.rs
Domenico e484ea28ca Sdk implementation: Sfrax adapter and substream (#91)
* feat: initial setup

* feat: implemented getCapabilities and getTokens

* chore: adjusted getPoolIds

* feat: Initial implementation of getLimits()

* feat: implemented getLimits, getTokens and internal functions for amounts

* feat: implemented price

* feat: implemented swap function

* fix and test: fixed minor issues on adapter and setup test

* debugging price function

* fix: debugged price function and fixed getPriceAt function

* test: testOneIncreasingPriceFoundFraxV3SFrax

* fix: debugging and fixing buy function

* fix: fixed getPriceAt

* test: testing post trade price

* fix: Fixed getPriceAt

* fix: Fixed getLimits

* fix: Fixed prices and improved readability

* fix: Fixed price and transfers in swap

* feat: Finished tests

* chore: Changed approve to safeIncreaseAllowance

* feat: created substream for staked frax

* feat: remove useless files

* feat: fixed dependencies in cargo.toml

* feat: rename folder

* feat: updated cargo.lock

* feat: changed lib.rs, added modules.rs

* feat: update modules.rs with corrects addresses

* feat: rename folder in ethereum-sfrax

* feat: remove useless comments, change locked asset address, rename

* feat: undo changes on mod.rs in ethereum-balancer

* feat: rename variable

* feat: update substreams/cargo.toml

* feat: modify ristfmt.toml

* feat: performed code formatting

* feat: modify src/abi

* feat: performed formatting with nightly

* feat: fix addition opeation

* feat: adjust code with for i, f

* feat: performed fmt inside ethereum-sfrax folder

* feat: performed clippy

* feat: fix with clippy warning suggests

* feat: undo any change in ethereum-balancer

* feat: change stakedfrax_contract.rs

* fix: stakedfrax_contract.rs

* feat: add blank line

* feat: add #[allow(clippy::all)] on ethereum-sfrax/src/abi/mod.rs

* feat: update comments on pool_factories.rs

* feat: update cargo.toml and substreams.yaml

* feat: add tycho evm in pb folder

* feat: add params to take contracts' addresses

* feat: add logic to map rewards_cycle

* feat: performed fmt and fix versioning

* feat: remove useless functions

* feat: add logic to track rewards_to_distribute

* feat: passing CI

* fix: substreams.yaml

* feat: fixed params in manifest

Co-authored-by: mrBovo <bovo.ignazio@proton.me>

* feat: fixed error in map_relative_balances function

* feat: passing CI checks

* fix: 🐛 hex-binary address encoding + refactoring vault-> underlying map

* style: 💄 fix formatting

* feat: Implemented testPoolBehaviour

* alignment with propeller main

* Update forge-std submodule reference to include ds-test

* files update to match propeller/main

* creating integration_test fir sfrax

* fixed FraxV3SFraxAdapter.sol import paths

* updated with correct addresses FraxV3SFraxAdapter manifest.yaml

* updated sfrax manifest.yaml

* updated to support sdk

* integration_test sfrax updated

* fix: 🐛 add reward processing

* chore: ♻️ minor cleanups

* fix: Fixed adapter limits

* fix: fix adapter and substream sdk tests

* fix: Fixed CI errors

* chore: fmt

* chore: Removed unused line

* fix: Fixed clippy warnings

* chore: formatted with rustup

* chore: Removed unused line

* chore: post-build formatting

* chore: Formatting using different toolchain vesion

* chore: 💄 format

* chore: 💄 format 2

* chore: Using static address for frax

* feat: Added second constructor param for sfrax

* fix: Fixed limits on frax sell

* chore: Fixed merge conflict with sfraxeth

* chore: Remove sfraxeth_contract changes

* chore: Fixed EOFs

* fix: Fixed fmt on stakedfrax contract

---------

Co-authored-by: mp-web3 <mp.web3.t@gmail.com>
Co-authored-by: gabrir99 <gabri.ruini@gmail.com>
Co-authored-by: mrBovo <bovo.ignazio@proton.me>
Co-authored-by: Ignazio Bovo <ignazio@jsgenesis.com>
Co-authored-by: mrBovo <bovoignazio.dev@gmail.com>
Co-authored-by: Mattia <mp.web3@gmail.com>
2024-10-25 18:53:06 +01:00

509 lines
20 KiB
Rust

// @generated
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Events {
#[prost(message, repeated, tag="1")]
pub stakedfrax_approvals: ::prost::alloc::vec::Vec<StakedfraxApproval>,
#[prost(message, repeated, tag="2")]
pub stakedfrax_deposits: ::prost::alloc::vec::Vec<StakedfraxDeposit>,
#[prost(message, repeated, tag="3")]
pub stakedfrax_distribute_rewards: ::prost::alloc::vec::Vec<StakedfraxDistributeRewards>,
#[prost(message, repeated, tag="4")]
pub stakedfrax_set_max_distribution_per_second_per_assets: ::prost::alloc::vec::Vec<StakedfraxSetMaxDistributionPerSecondPerAsset>,
#[prost(message, repeated, tag="5")]
pub stakedfrax_sync_rewards: ::prost::alloc::vec::Vec<StakedfraxSyncRewards>,
#[prost(message, repeated, tag="6")]
pub stakedfrax_timelock_transfer_starteds: ::prost::alloc::vec::Vec<StakedfraxTimelockTransferStarted>,
#[prost(message, repeated, tag="7")]
pub stakedfrax_timelock_transferreds: ::prost::alloc::vec::Vec<StakedfraxTimelockTransferred>,
#[prost(message, repeated, tag="8")]
pub stakedfrax_transfers: ::prost::alloc::vec::Vec<StakedfraxTransfer>,
#[prost(message, repeated, tag="9")]
pub stakedfrax_withdraws: ::prost::alloc::vec::Vec<StakedfraxWithdraw>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Calls {
#[prost(message, repeated, tag="1")]
pub stakedfrax_call_accept_transfer_timelocks: ::prost::alloc::vec::Vec<StakedfraxAcceptTransferTimelockCall>,
#[prost(message, repeated, tag="2")]
pub stakedfrax_call_approves: ::prost::alloc::vec::Vec<StakedfraxApproveCall>,
#[prost(message, repeated, tag="3")]
pub stakedfrax_call_deposits: ::prost::alloc::vec::Vec<StakedfraxDepositCall>,
#[prost(message, repeated, tag="4")]
pub stakedfrax_call_deposit_with_signatures: ::prost::alloc::vec::Vec<StakedfraxDepositWithSignatureCall>,
#[prost(message, repeated, tag="5")]
pub stakedfrax_call_mints: ::prost::alloc::vec::Vec<StakedfraxMintCall>,
#[prost(message, repeated, tag="6")]
pub stakedfrax_call_permits: ::prost::alloc::vec::Vec<StakedfraxPermitCall>,
#[prost(message, repeated, tag="7")]
pub stakedfrax_call_redeems: ::prost::alloc::vec::Vec<StakedfraxRedeemCall>,
#[prost(message, repeated, tag="8")]
pub stakedfrax_call_renounce_timelocks: ::prost::alloc::vec::Vec<StakedfraxRenounceTimelockCall>,
#[prost(message, repeated, tag="9")]
pub stakedfrax_call_set_max_distribution_per_second_per_assets: ::prost::alloc::vec::Vec<StakedfraxSetMaxDistributionPerSecondPerAssetCall>,
#[prost(message, repeated, tag="10")]
pub stakedfrax_call_sync_rewards_and_distributions: ::prost::alloc::vec::Vec<StakedfraxSyncRewardsAndDistributionCall>,
#[prost(message, repeated, tag="11")]
pub stakedfrax_call_transfers: ::prost::alloc::vec::Vec<StakedfraxTransferCall>,
#[prost(message, repeated, tag="12")]
pub stakedfrax_call_transfer_froms: ::prost::alloc::vec::Vec<StakedfraxTransferFromCall>,
#[prost(message, repeated, tag="13")]
pub stakedfrax_call_transfer_timelocks: ::prost::alloc::vec::Vec<StakedfraxTransferTimelockCall>,
#[prost(message, repeated, tag="14")]
pub stakedfrax_call_withdraws: ::prost::alloc::vec::Vec<StakedfraxWithdrawCall>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxApproval {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub owner: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub spender: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="7")]
pub amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxDeposit {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub caller: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub owner: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="7")]
pub assets: ::prost::alloc::string::String,
#[prost(string, tag="8")]
pub shares: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxDistributeRewards {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(string, tag="5")]
pub rewards_to_distribute: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxSetMaxDistributionPerSecondPerAsset {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(string, tag="5")]
pub old_max: ::prost::alloc::string::String,
#[prost(string, tag="6")]
pub new_max: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxSyncRewards {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(uint64, tag="5")]
pub cycle_end: u64,
#[prost(uint64, tag="6")]
pub last_sync: u64,
#[prost(string, tag="7")]
pub reward_cycle_amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTimelockTransferStarted {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub previous_timelock: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub new_timelock: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTimelockTransferred {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub previous_timelock: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub new_timelock: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTransfer {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub from: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub to: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="7")]
pub amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxWithdraw {
#[prost(string, tag="1")]
pub evt_tx_hash: ::prost::alloc::string::String,
#[prost(uint32, tag="2")]
pub evt_index: u32,
#[prost(message, optional, tag="3")]
pub evt_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="4")]
pub evt_block_number: u64,
#[prost(bytes="vec", tag="5")]
pub caller: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="6")]
pub receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="7")]
pub owner: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub assets: ::prost::alloc::string::String,
#[prost(string, tag="9")]
pub shares: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxAcceptTransferTimelockCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxApproveCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(bytes="vec", tag="6")]
pub spender: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="7")]
pub amount: ::prost::alloc::string::String,
#[prost(bool, tag="8")]
pub output_param0: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxDepositCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_assets: ::prost::alloc::string::String,
#[prost(bytes="vec", tag="7")]
pub u_receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub output_shares: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxDepositWithSignatureCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_assets: ::prost::alloc::string::String,
#[prost(bytes="vec", tag="7")]
pub u_receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub u_deadline: ::prost::alloc::string::String,
#[prost(bool, tag="9")]
pub u_approve_max: bool,
#[prost(uint64, tag="10")]
pub u_v: u64,
#[prost(bytes="vec", tag="11")]
pub u_r: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="12")]
pub u_s: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="13")]
pub output_shares: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxMintCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_shares: ::prost::alloc::string::String,
#[prost(bytes="vec", tag="7")]
pub u_receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub output_assets: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxPermitCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(bytes="vec", tag="6")]
pub owner: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="7")]
pub spender: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub value: ::prost::alloc::string::String,
#[prost(string, tag="9")]
pub deadline: ::prost::alloc::string::String,
#[prost(uint64, tag="10")]
pub v: u64,
#[prost(bytes="vec", tag="11")]
pub r: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="12")]
pub s: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxRedeemCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_shares: ::prost::alloc::string::String,
#[prost(bytes="vec", tag="7")]
pub u_receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="8")]
pub u_owner: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="9")]
pub output_assets: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxRenounceTimelockCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxSetMaxDistributionPerSecondPerAssetCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_max_distribution_per_second_per_asset: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxSyncRewardsAndDistributionCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTransferCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(bytes="vec", tag="6")]
pub to: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="7")]
pub amount: ::prost::alloc::string::String,
#[prost(bool, tag="8")]
pub output_param0: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTransferFromCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(bytes="vec", tag="6")]
pub from: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="7")]
pub to: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="8")]
pub amount: ::prost::alloc::string::String,
#[prost(bool, tag="9")]
pub output_param0: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxTransferTimelockCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(bytes="vec", tag="6")]
pub u_new_timelock: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StakedfraxWithdrawCall {
#[prost(string, tag="1")]
pub call_tx_hash: ::prost::alloc::string::String,
#[prost(message, optional, tag="2")]
pub call_block_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(uint64, tag="3")]
pub call_block_number: u64,
#[prost(uint64, tag="4")]
pub call_ordinal: u64,
#[prost(bool, tag="5")]
pub call_success: bool,
#[prost(string, tag="6")]
pub u_assets: ::prost::alloc::string::String,
#[prost(bytes="vec", tag="7")]
pub u_receiver: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes="vec", tag="8")]
pub u_owner: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="9")]
pub output_shares: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RewardCycle {
#[prost(uint64, tag="1")]
pub ord: u64,
#[prost(bytes="vec", tag="2")]
pub reward_rate: ::prost::alloc::vec::Vec<u8>,
#[prost(string, tag="3")]
pub component_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BlockRewardCycles {
#[prost(message, repeated, tag="1")]
pub reward_cycles: ::prost::alloc::vec::Vec<RewardCycle>,
}
// @@protoc_insertion_point(module)