Struct Swap

pub struct Swap {
    pub id: <PoolId as SolType>::RustType,
    pub sender: Address,
    pub amount0: i128,
    pub amount1: i128,
    pub sqrtPriceX96: U160,
    pub liquidity: u128,
    pub tick: I24,
    pub fee: U24,
}

@notice Emitted for swaps between currency0 and currency1 @param id The abi encoded hash of the pool key struct for the pool that was modified @param sender The address that initiated the swap call, and that received the callback @param amount0 The delta of the currency0 balance of the pool @param amount1 The delta of the currency1 balance of the pool @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96 @param liquidity The liquidity of the pool after the swap @param tick The log base 1.0001 of the price of the pool after the swap Event with signature Swap(bytes32,address,int128,int128,uint160,uint128,int24,uint24) and selector 0x40e9cecb9f5f1f1c5b9c97dec2917b7ee92e57ba5563708daca94dd84ad7112f.

event Swap(PoolId indexed id, address indexed sender, int128 amount0, int128 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint24 fee);

Fields

id: <PoolId as SolType>::RustType

sender: Address

amount0: i128

amount1: i128

sqrtPriceX96: U160

liquidity: u128

tick: I24

fee: U24

Trait Implementations

impl Clone for Swap

fn clone(&self) -> Swap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Swap

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

Formats the value using the given formatter.

impl From<&Swap> for LogData

fn from(this: &Swap) -> LogData

Converts to this type from the input type.

impl IntoLogData for Swap

fn to_log_data(&self) -> LogData

Convert into a [LogData] object.

fn into_log_data(self) -> LogData

Consume and convert into a [LogData] object.

impl PartialEq for Swap

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

const SIGNATURE: &'static str = "Swap(bytes32,address,int128,int128,uint160,uint128,int24,uint24)"

The event’s ABI signature.

const SIGNATURE_HASH: B256 = _

The event’s ABI signature hash, or selector: keccak256(SIGNATURE)

const ANONYMOUS: bool = false

Whether the event is anonymous.

type DataTuple<'a> = (Int<128>, Int<128>, Uint<160>, Uint<128>, Int<24>, Uint<24>)

The underlying tuple type which represents this event’s non-indexed parameters. These parameters are ABI encoded and included in the log body.

type DataToken<'a> = <<Swap as SolEvent>::DataTuple<'a> as SolType>::Token<'a>

The [TokenSeq] type corresponding to the tuple.

type TopicList = (FixedBytes<32>, PoolId, Address)

The underlying tuple type which represents this event’s topics.

fn new( topics: <Self::TopicList as SolType>::RustType, data: <Self::DataTuple<'_> as SolType>::RustType, ) -> Self

Convert decoded rust data to the event type.

fn check_signature( topics: &<Self::TopicList as SolType>::RustType, ) -> Result<()>

Check that the event’s signature matches the given topics.

fn tokenize_body(&self) -> Self::DataToken<'_>

Tokenize the event’s non-indexed parameters.

fn topics(&self) -> <Self::TopicList as SolType>::RustType

The event’s topics.

fn encode_topics_raw(&self, out: &mut [WordToken]) -> Result<()>

Encode the topics of this event into the given buffer.

fn new_checked( topics: <Self::TopicList as SolType>::RustType, data: <Self::DataTuple<'_> as SolType>::RustType, ) -> Result<Self, Error>

Convert decoded rust data to the event type.

fn abi_encoded_size(&self) -> usize

The size of the ABI-encoded dynamic data in bytes.

fn encode_data_to(&self, out: &mut Vec<u8>)

ABI-encode the dynamic data of this event into the given buffer.

fn encode_data(&self) -> Vec<u8>

ABI-encode the dynamic data of this event.

fn encode_topics(&self) -> Vec<WordToken>

Encode the topics of this event.

fn encode_topics_array<const LEN: usize>(&self) -> [WordToken; LEN]

Encode the topics of this event into a fixed-size array.

fn encode_log_data(&self) -> LogData

Encode this event to a [LogData].

fn encode_log(log: &Log<Self>) -> Log

Transform ca [Log] containing this event into a [Log] containing [LogData].

fn decode_topics<I, D>( topics: I, ) -> Result<<Self::TopicList as SolType>::RustType, Error>

where I: IntoIterator<Item = D>, D: Into<WordToken>,

Decode the topics of this event from the given data.

fn abi_decode_data<'a>( data: &'a [u8], validate: bool, ) -> Result<<Self::DataTuple<'a> as SolType>::RustType, Error>

ABI-decodes the dynamic data of this event from the given buffer.

fn decode_raw_log<I, D>( topics: I, data: &[u8], validate: bool, ) -> Result<Self, Error>

where I: IntoIterator<Item = D>, D: Into<WordToken>,

Decode the event from the given log info.

fn decode_log_data(log: &LogData, validate: bool) -> Result<Self, Error>

Decode the event from the given log object.

fn decode_log(log: &Log, validate: bool) -> Result<Log<Self>, Error>

Decode the event from the given log object.

impl Eq for Swap

impl StructuralPartialEq for Swap

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 144 bytes