Struct PoolSwap 

pub struct PoolSwap {

    pub chain: SharedChain,
    pub dex: SharedDex,
    pub instrument_id: InstrumentId,
    pub pool_identifier: PoolIdentifier,
    pub block: u64,
    pub transaction_hash: String,
    pub transaction_index: u32,
    pub log_index: u32,
    pub sender: Address,
    pub recipient: Address,
    pub sqrt_price_x96: U160,
    pub amount0: I256,
    pub amount1: I256,
    pub liquidity: u128,
    pub tick: i32,
    pub timestamp: Option<UnixNanos>,
    pub ts_init: Option<UnixNanos>,
    pub trade_info: Option<SwapTradeInfo>,
}

Represents a token swap transaction on a decentralized exchange (DEX).

This structure captures both the raw blockchain data from a swap event and optionally includes computed market-oriented trade information. It serves as the primary data structure for tracking and analyzing DEX swap activity.

Fields

chain: SharedChain

The blockchain network where the swap occurred.

dex: SharedDex

The decentralized exchange where the swap was executed.

instrument_id: InstrumentId

The instrument ID for this pool’s trading pair.

pool_identifier: PoolIdentifier

The unique identifier for this pool (could be an address or other protocol-specific hex string).

block: u64

The blockchain block number at which the swap was executed.

transaction_hash: String

The unique hash identifier of the blockchain transaction containing the swap.

transaction_index: u32

The index position of the transaction within the block.

log_index: u32

The index position of the swap event log within the transaction.

sender: Address

The blockchain address of the user or contract that initiated the swap.

recipient: Address

The blockchain address that received the swapped tokens.

sqrt_price_x96: U160

The sqrt price after the swap (Q64.96 format).

amount0: I256

The amount of token0 involved in the swap.

amount1: I256

The amount of token1 involved in the swap.

liquidity: u128

The liquidity of the pool after the swap occurred.

tick: i32

The current tick of the pool after the swap occurred.

timestamp: Option<UnixNanos>

UNIX timestamp (nanoseconds) when the swap occurred.

ts_init: Option<UnixNanos>

UNIX timestamp (nanoseconds) when the instance was initialized.

trade_info: Option<SwapTradeInfo>

Optional computed trade information in market-oriented format. This translates raw blockchain data into standard trading terminology.

Implementations

impl PoolSwap

pub fn new( chain: SharedChain, dex: SharedDex, instrument_id: InstrumentId, pool_identifier: PoolIdentifier, block: u64, transaction_hash: String, transaction_index: u32, log_index: u32, timestamp: Option<UnixNanos>, sender: Address, recipient: Address, amount0: I256, amount1: I256, sqrt_price_x96: U160, liquidity: u128, tick: i32, ) -> Self

Creates a new PoolSwap instance with the specified properties.

pub fn calculate_trade_info( &mut self, token0: &Token, token1: &Token, sqrt_price_x96: Option<U160>, ) -> Result<()>

Calculates and populates the trade_info field with market-oriented trade data.

This method transforms the raw blockchain swap data (token0/token1 amounts) into standard trading terminology (base/quote, buy/sell, execution price). The computation determines token roles based on priority and handles decimal adjustments.

Arguments

• token0 - Reference to token0 in the pool
• token1 - Reference to token1 in the pool
• sqrt_price_x96 - Optional square root price before the swap (Q96 format) for calculating price impact and slippage

Errors

Returns an error if the trade info computation or price calculations fail.

Trait Implementations

impl Clone for PoolSwap

fn clone(&self) -> PoolSwap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PoolSwap

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

Formats the value using the given formatter.

impl Display for PoolSwap

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

Formats the value using the given formatter.

impl From<PoolSwap> for DefiData

fn from(value: PoolSwap) -> Self

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for PoolSwap

type Target = PoolSwap

The Python output type

type Output = Bound<'py, <PoolSwap 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 PoolSwap

fn eq(&self, other: &PoolSwap) -> 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 PoolSwap

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PoolSwap

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 token swap transaction on a decentralized exchange (DEX). /// /// This structure captures both the raw blockchain data from a swap event and /// optionally includes computed market-oriented trade information. It serves as /// the primary data structure for tracking and analyzing DEX swap activity.

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<PoolSwap>

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 PoolSwap

const TEXT_SIGNATURE: &'static str = "(chain, dex, instrument_id, pool_identifier, block, transaction_hash, transaction_index, log_index, timestamp, sender, receiver, amount0, amount1, sqrt_price_x96, liquidity, tick)"

impl PyMethods<PoolSwap> for PyClassImplCollector<PoolSwap>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PoolSwap

const NAME: &'static str = "PoolSwap"

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 DerefToPyAny for PoolSwap

impl ExtractPyClassWithClone for PoolSwap

impl StructuralPartialEq for PoolSwap