Struct PoolFlash 

pub struct PoolFlash {

    pub chain: SharedChain,
    pub dex: SharedDex,
    pub instrument_id: InstrumentId,
    pub pool_address: Address,
    pub block: u64,
    pub transaction_hash: String,
    pub transaction_index: u32,
    pub log_index: u32,
    pub ts_event: Option<UnixNanos>,
    pub sender: Address,
    pub recipient: Address,
    pub amount0: U256,
    pub amount1: U256,
    pub paid0: U256,
    pub paid1: U256,
}

Represents a flash loan event from a Uniswap V3 pool.

Flash loans allow users to borrow tokens without collateral as long as they are returned within the same transaction. Fees are paid on the borrowed amount, which are added to the pool’s fee growth accumulators.

Fields

chain: SharedChain

The blockchain network where the flash loan occurred.

dex: SharedDex

The decentralized exchange where the flash loan was executed.

instrument_id: InstrumentId

The instrument ID for this pool’s trading pair.

pool_address: Address

The blockchain address of the pool smart contract.

block: u64

The blockchain block number at which the flash loan was executed.

transaction_hash: String

The unique hash identifier of the blockchain transaction containing the flash loan.

transaction_index: u32

The index position of the transaction within the block.

log_index: u32

The index position of the flash loan event log within the transaction.

ts_event: Option<UnixNanos>

The UNIX timestamp (nanoseconds) when the event occurred.

sender: Address

The blockchain address of the user or contract that initiated the flash loan.

recipient: Address

The blockchain address that received the flash loan.

amount0: U256

The amount of token0 borrowed.

amount1: U256

The amount of token1 borrowed.

paid0: U256

The amount of token0 paid back (including fees).

paid1: U256

The amount of token1 paid back (including fees).

Implementations

impl PoolFlash

pub fn new( chain: SharedChain, dex: SharedDex, instrument_id: InstrumentId, pool_address: Address, block_number: u64, transaction_hash: String, transaction_index: u32, log_index: u32, ts_event: Option<UnixNanos>, sender: Address, recipient: Address, amount0: U256, amount1: U256, paid0: U256, paid1: U256, ) -> Self

Creates a new PoolFlash instance with the specified parameters.

Trait Implementations

impl Clone for PoolFlash

fn clone(&self) -> PoolFlash

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PoolFlash

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PoolFlash

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PoolFlash

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'py> IntoPyObject<'py> for PoolFlash

type Target = PoolFlash

The Python output type

type Output = Bound<'py, <PoolFlash as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for PoolFlash

fn eq(&self, other: &PoolFlash) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for PoolFlash

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PoolFlash

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Represents a flash loan event from a Uniswap V3 pool. /// /// Flash loans allow users to borrow tokens without collateral as long as they are returned /// within the same transaction. Fees are paid on the borrowed amount, which are added to /// the pool's fee growth accumulators.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PoolFlash>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for PoolFlash

const TEXT_SIGNATURE: &'static str = "(chain, dex, pool_address, instrument_id, block, transaction_hash, transaction_index, log_index, sender, recipient, amount0, amount1, paid0, paid1, timestamp)"

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder PoolFlash

type Holder = Option<PyClassGuard<'a, PoolFlash>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut PoolFlash

type Holder = Option<PyClassGuardMut<'a, PoolFlash>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<PoolFlash> for PyClassImplCollector<PoolFlash>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PoolFlash

const NAME: &'static str = "PoolFlash"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Serialize for PoolFlash

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for PoolFlash

impl StructuralPartialEq for PoolFlash