const INTERNAL_ERR: &'static str = "`ethabi_derive` internal error"; /// Contract's functions. #[allow(dead_code, unused_imports, unused_variables)] pub mod functions { use super::INTERNAL_ERR; #[derive(Debug, Clone, PartialEq)] pub struct Weth {} impl Weth { const METHOD_ID: [u8; 4] = [173u8, 92u8, 70u8, 72u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Ok(Self {}) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode(&[ethabi::ParamType::Address], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for Weth { const NAME: &'static str = "WETH"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for Weth { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct BatchSwap { pub kind: substreams::scalar::BigInt, pub swaps: Vec<( [u8; 32usize], substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, )>, pub assets: Vec>, pub funds: (Vec, bool, Vec, bool), pub limits: Vec, pub deadline: substreams::scalar::BigInt, } impl BatchSwap { const METHOD_ID: [u8; 4] = [148u8, 91u8, 206u8, 201u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::Uint(8usize), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Tuple(vec![ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Bytes, ]))), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Address, ethabi::ParamType::Bool, ethabi::ParamType::Address, ethabi::ParamType::Bool, ]), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Int(256usize))), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { kind: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, swaps: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let tuple_elements = inner.into_tuple().expect(INTERNAL_ERR); ( { let mut result = [0u8; 32]; let v = tuple_elements[0usize] .clone() .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, { let mut v = [0 as u8; 32]; tuple_elements[1usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; tuple_elements[2usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; tuple_elements[3usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[4usize] .clone() .into_bytes() .expect(INTERNAL_ERR), ) }) .collect(), assets: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), funds: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( tuple_elements[0usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[1usize] .clone() .into_bool() .expect(INTERNAL_ERR), tuple_elements[2usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[3usize] .clone() .into_bool() .expect(INTERNAL_ERR), ) }, limits: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }) .collect(), deadline: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.kind.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), { let v = self .swaps .iter() .map(|inner| { ethabi::Token::Tuple(vec![ ethabi::Token::FixedBytes(inner.0.as_ref().to_vec()), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.1.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.2.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.3.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Bytes(inner.4.clone()), ]) }) .collect(); ethabi::Token::Array(v) }, { let v = self .assets .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Tuple(vec![ ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.0)), ethabi::Token::Bool(self.funds.1.clone()), ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.2)), ethabi::Token::Bool(self.funds.3.clone()), ]), { let v = self .limits .iter() .map(|inner| { let non_full_signed_bytes = inner.to_signed_bytes_be(); let full_signed_bytes_init = if non_full_signed_bytes[0] & 0x80 == 0x80 { 0xff } else { 0x00 }; let mut full_signed_bytes = [full_signed_bytes_init as u8; 32]; non_full_signed_bytes .into_iter() .rev() .enumerate() .for_each(|(i, byte)| full_signed_bytes[31 - i] = byte); ethabi::Token::Int(ethabi::Int::from_big_endian( full_signed_bytes.as_ref(), )) }) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.deadline.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Int(256usize)))], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }) .collect()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for BatchSwap { const NAME: &'static str = "batchSwap"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for BatchSwap { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct DeregisterTokens { pub pool_id: [u8; 32usize], pub tokens: Vec>, } impl DeregisterTokens { const METHOD_ID: [u8; 4] = [125u8, 58u8, 235u8, 150u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec()), { let v = self .tokens .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for DeregisterTokens { const NAME: &'static str = "deregisterTokens"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct ExitPool { pub pool_id: [u8; 32usize], pub sender: Vec, pub recipient: Vec, pub request: (Vec>, Vec, Vec, bool), } impl ExitPool { const METHOD_ID: [u8; 4] = [139u8, 219u8, 57u8, 19u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Address, ethabi::ParamType::Address, ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize))), ethabi::ParamType::Bytes, ethabi::ParamType::Bool, ]), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, sender: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), recipient: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), request: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( tuple_elements[0usize] .clone() .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), tuple_elements[1usize] .clone() .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect(), tuple_elements[2usize] .clone() .into_bytes() .expect(INTERNAL_ERR), tuple_elements[3usize] .clone() .into_bool() .expect(INTERNAL_ERR), ) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec()), ethabi::Token::Address(ethabi::Address::from_slice(&self.sender)), ethabi::Token::Address(ethabi::Address::from_slice(&self.recipient)), ethabi::Token::Tuple(vec![ { let v = self .request .0 .iter() .map(|inner| { ethabi::Token::Address(ethabi::Address::from_slice(&inner)) }) .collect(); ethabi::Token::Array(v) }, { let v = self .request .1 .iter() .map(|inner| { ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )) }) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Bytes(self.request.2.clone()), ethabi::Token::Bool(self.request.3.clone()), ]), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for ExitPool { const NAME: &'static str = "exitPool"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct FlashLoan { pub recipient: Vec, pub tokens: Vec>, pub amounts: Vec, pub user_data: Vec, } impl FlashLoan { const METHOD_ID: [u8; 4] = [92u8, 56u8, 68u8, 158u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::Address, ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize))), ethabi::ParamType::Bytes, ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { recipient: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), amounts: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect(), user_data: values .pop() .expect(INTERNAL_ERR) .into_bytes() .expect(INTERNAL_ERR), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Address(ethabi::Address::from_slice(&self.recipient)), { let v = self .tokens .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, { let v = self .amounts .iter() .map(|inner| { ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )) }) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Bytes(self.user_data.clone()), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for FlashLoan { const NAME: &'static str = "flashLoan"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct GetActionId { pub selector: [u8; 4usize], } impl GetActionId { const METHOD_ID: [u8; 4] = [133u8, 28u8, 27u8, 179u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(4usize)], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { selector: { let mut result = [0u8; 4]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::FixedBytes(self.selector.as_ref().to_vec())]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result<[u8; 32usize], String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result<[u8; 32usize], String> { let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(32usize)], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok({ let mut result = [0u8; 32]; let v = values .pop() .expect("one output data should have existed") .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option<[u8; 32usize]> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetActionId { const NAME: &'static str = "getActionId"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<[u8; 32usize]> for GetActionId { fn output(data: &[u8]) -> Result<[u8; 32usize], String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetAuthorizer {} impl GetAuthorizer { const METHOD_ID: [u8; 4] = [170u8, 171u8, 173u8, 197u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Ok(Self {}) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode(&[ethabi::ParamType::Address], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetAuthorizer { const NAME: &'static str = "getAuthorizer"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for GetAuthorizer { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetDomainSeparator {} impl GetDomainSeparator { const METHOD_ID: [u8; 4] = [237u8, 36u8, 145u8, 29u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Ok(Self {}) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result<[u8; 32usize], String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result<[u8; 32usize], String> { let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(32usize)], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok({ let mut result = [0u8; 32]; let v = values .pop() .expect("one output data should have existed") .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option<[u8; 32usize]> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetDomainSeparator { const NAME: &'static str = "getDomainSeparator"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<[u8; 32usize]> for GetDomainSeparator { fn output(data: &[u8]) -> Result<[u8; 32usize], String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetInternalBalance { pub user: Vec, pub tokens: Vec>, } impl GetInternalBalance { const METHOD_ID: [u8; 4] = [15u8, 90u8, 110u8, 250u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::Address, ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { user: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Address(ethabi::Address::from_slice(&self.user)), { let v = self .tokens .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize)))], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetInternalBalance { const NAME: &'static str = "getInternalBalance"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for GetInternalBalance { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetNextNonce { pub user: Vec, } impl GetNextNonce { const METHOD_ID: [u8; 4] = [144u8, 25u8, 59u8, 124u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::Address], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { user: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::Address(ethabi::Address::from_slice(&self.user))]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Uint(256usize)], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok({ let mut v = [0 as u8; 32]; values .pop() .expect("one output data should have existed") .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetNextNonce { const NAME: &'static str = "getNextNonce"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable for GetNextNonce { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetPausedState {} impl GetPausedState { const METHOD_ID: [u8; 4] = [28u8, 13u8, 224u8, 81u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Ok(Self {}) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result<(bool, substreams::scalar::BigInt, substreams::scalar::BigInt), String> { Self::output(call.return_data.as_ref()) } pub fn output( data: &[u8], ) -> Result<(bool, substreams::scalar::BigInt, substreams::scalar::BigInt), String> { let mut values = ethabi::decode( &[ ethabi::ParamType::Bool, ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; values.reverse(); Ok(( values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, )) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call( &self, address: Vec, ) -> Option<(bool, substreams::scalar::BigInt, substreams::scalar::BigInt)> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetPausedState { const NAME: &'static str = "getPausedState"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<( bool, substreams::scalar::BigInt, substreams::scalar::BigInt, )> for GetPausedState { fn output( data: &[u8], ) -> Result<(bool, substreams::scalar::BigInt, substreams::scalar::BigInt), String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetPool { pub pool_id: [u8; 32usize], } impl GetPool { const METHOD_ID: [u8; 4] = [246u8, 192u8, 9u8, 39u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(32usize)], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec())]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result<(Vec, substreams::scalar::BigInt), String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result<(Vec, substreams::scalar::BigInt), String> { let mut values = ethabi::decode( &[ethabi::ParamType::Address, ethabi::ParamType::Uint(8usize)], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; values.reverse(); Ok(( values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, )) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option<(Vec, substreams::scalar::BigInt)> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetPool { const NAME: &'static str = "getPool"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<(Vec, substreams::scalar::BigInt)> for GetPool { fn output(data: &[u8]) -> Result<(Vec, substreams::scalar::BigInt), String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetPoolTokenInfo { pub pool_id: [u8; 32usize], pub token: Vec, } impl GetPoolTokenInfo { const METHOD_ID: [u8; 4] = [176u8, 95u8, 142u8, 72u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Address], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, token: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec()), ethabi::Token::Address(ethabi::Address::from_slice(&self.token)), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result< ( substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, ), String, > { Self::output(call.return_data.as_ref()) } pub fn output( data: &[u8], ) -> Result< ( substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, ), String, > { let mut values = ethabi::decode( &[ ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Address, ], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; values.reverse(); Ok(( { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), )) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call( &self, address: Vec, ) -> Option<( substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, )> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetPoolTokenInfo { const NAME: &'static str = "getPoolTokenInfo"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<( substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, )> for GetPoolTokenInfo { fn output( data: &[u8], ) -> Result< ( substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, ), String, > { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetPoolTokens { pub pool_id: [u8; 32usize], } impl GetPoolTokens { const METHOD_ID: [u8; 4] = [249u8, 77u8, 70u8, 104u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(32usize)], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec())]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result< (Vec>, Vec, substreams::scalar::BigInt), String, > { Self::output(call.return_data.as_ref()) } pub fn output( data: &[u8], ) -> Result< (Vec>, Vec, substreams::scalar::BigInt), String, > { let mut values = ethabi::decode( &[ ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize))), ethabi::ParamType::Uint(256usize), ], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; values.reverse(); Ok(( values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect(), { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, )) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call( &self, address: Vec, ) -> Option<(Vec>, Vec, substreams::scalar::BigInt)> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetPoolTokens { const NAME: &'static str = "getPoolTokens"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<( Vec>, Vec, substreams::scalar::BigInt, )> for GetPoolTokens { fn output( data: &[u8], ) -> Result< (Vec>, Vec, substreams::scalar::BigInt), String, > { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetProtocolFeesCollector {} impl GetProtocolFeesCollector { const METHOD_ID: [u8; 4] = [210u8, 148u8, 108u8, 43u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Ok(Self {}) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode(&[ethabi::ParamType::Address], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for GetProtocolFeesCollector { const NAME: &'static str = "getProtocolFeesCollector"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for GetProtocolFeesCollector { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct HasApprovedRelayer { pub user: Vec, pub relayer: Vec, } impl HasApprovedRelayer { const METHOD_ID: [u8; 4] = [254u8, 201u8, 13u8, 114u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ethabi::ParamType::Address, ethabi::ParamType::Address], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { user: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), relayer: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Address(ethabi::Address::from_slice(&self.user)), ethabi::Token::Address(ethabi::Address::from_slice(&self.relayer)), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Bool], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_bool() .expect(INTERNAL_ERR)) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for HasApprovedRelayer { const NAME: &'static str = "hasApprovedRelayer"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable for HasApprovedRelayer { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct JoinPool { pub pool_id: [u8; 32usize], pub sender: Vec, pub recipient: Vec, pub request: (Vec>, Vec, Vec, bool), } impl JoinPool { const METHOD_ID: [u8; 4] = [185u8, 92u8, 172u8, 40u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Address, ethabi::ParamType::Address, ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize))), ethabi::ParamType::Bytes, ethabi::ParamType::Bool, ]), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, sender: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), recipient: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), request: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( tuple_elements[0usize] .clone() .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), tuple_elements[1usize] .clone() .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect(), tuple_elements[2usize] .clone() .into_bytes() .expect(INTERNAL_ERR), tuple_elements[3usize] .clone() .into_bool() .expect(INTERNAL_ERR), ) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec()), ethabi::Token::Address(ethabi::Address::from_slice(&self.sender)), ethabi::Token::Address(ethabi::Address::from_slice(&self.recipient)), ethabi::Token::Tuple(vec![ { let v = self .request .0 .iter() .map(|inner| { ethabi::Token::Address(ethabi::Address::from_slice(&inner)) }) .collect(); ethabi::Token::Array(v) }, { let v = self .request .1 .iter() .map(|inner| { ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )) }) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Bytes(self.request.2.clone()), ethabi::Token::Bool(self.request.3.clone()), ]), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for JoinPool { const NAME: &'static str = "joinPool"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct ManagePoolBalance { pub ops: Vec<(substreams::scalar::BigInt, [u8; 32usize], Vec, substreams::scalar::BigInt)>, } impl ManagePoolBalance { const METHOD_ID: [u8; 4] = [230u8, 196u8, 96u8, 146u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Uint(8usize), ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Address, ethabi::ParamType::Uint(256usize), ])))], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { ops: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let tuple_elements = inner.into_tuple().expect(INTERNAL_ERR); ( { let mut v = [0 as u8; 32]; tuple_elements[0usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut result = [0u8; 32]; let v = tuple_elements[1usize] .clone() .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, tuple_elements[2usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), { let mut v = [0 as u8; 32]; tuple_elements[3usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, ) }) .collect(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[{ let v = self .ops .iter() .map(|inner| { ethabi::Token::Tuple(vec![ ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.0.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::FixedBytes(inner.1.as_ref().to_vec()), ethabi::Token::Address(ethabi::Address::from_slice(&inner.2)), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.3.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ]) }) .collect(); ethabi::Token::Array(v) }]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for ManagePoolBalance { const NAME: &'static str = "managePoolBalance"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct ManageUserBalance { pub ops: Vec<( substreams::scalar::BigInt, Vec, substreams::scalar::BigInt, Vec, Vec, )>, } impl ManageUserBalance { const METHOD_ID: [u8; 4] = [14u8, 142u8, 62u8, 132u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Uint(8usize), ethabi::ParamType::Address, ethabi::ParamType::Uint(256usize), ethabi::ParamType::Address, ethabi::ParamType::Address, ])))], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { ops: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let tuple_elements = inner.into_tuple().expect(INTERNAL_ERR); ( { let mut v = [0 as u8; 32]; tuple_elements[0usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[1usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), { let mut v = [0 as u8; 32]; tuple_elements[2usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[3usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[4usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), ) }) .collect(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[{ let v = self .ops .iter() .map(|inner| { ethabi::Token::Tuple(vec![ ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.0.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Address(ethabi::Address::from_slice(&inner.1)), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.2.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Address(ethabi::Address::from_slice(&inner.3)), ethabi::Token::Address(ethabi::Address::from_slice(&inner.4)), ]) }) .collect(); ethabi::Token::Array(v) }]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for ManageUserBalance { const NAME: &'static str = "manageUserBalance"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct QueryBatchSwap { pub kind: substreams::scalar::BigInt, pub swaps: Vec<( [u8; 32usize], substreams::scalar::BigInt, substreams::scalar::BigInt, substreams::scalar::BigInt, Vec, )>, pub assets: Vec>, pub funds: (Vec, bool, Vec, bool), } impl QueryBatchSwap { const METHOD_ID: [u8; 4] = [248u8, 77u8, 6u8, 110u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::Uint(8usize), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Tuple(vec![ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Bytes, ]))), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Address, ethabi::ParamType::Bool, ethabi::ParamType::Address, ethabi::ParamType::Bool, ]), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { kind: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, swaps: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let tuple_elements = inner.into_tuple().expect(INTERNAL_ERR); ( { let mut result = [0u8; 32]; let v = tuple_elements[0usize] .clone() .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, { let mut v = [0 as u8; 32]; tuple_elements[1usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; tuple_elements[2usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, { let mut v = [0 as u8; 32]; tuple_elements[3usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[4usize] .clone() .into_bytes() .expect(INTERNAL_ERR), ) }) .collect(), assets: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), funds: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( tuple_elements[0usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[1usize] .clone() .into_bool() .expect(INTERNAL_ERR), tuple_elements[2usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[3usize] .clone() .into_bool() .expect(INTERNAL_ERR), ) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.kind.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), { let v = self .swaps .iter() .map(|inner| { ethabi::Token::Tuple(vec![ ethabi::Token::FixedBytes(inner.0.as_ref().to_vec()), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.1.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.2.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match inner.3.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Bytes(inner.4.clone()), ]) }) .collect(); ethabi::Token::Array(v) }, { let v = self .assets .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, ethabi::Token::Tuple(vec![ ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.0)), ethabi::Token::Bool(self.funds.1.clone()), ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.2)), ethabi::Token::Bool(self.funds.3.clone()), ]), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result, String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result, String> { let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Int(256usize)))], data.as_ref(), ) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok(values .pop() .expect("one output data should have existed") .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }) .collect()) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for QueryBatchSwap { const NAME: &'static str = "queryBatchSwap"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable> for QueryBatchSwap { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct RegisterPool { pub specialization: substreams::scalar::BigInt, } impl RegisterPool { const METHOD_ID: [u8; 4] = [9u8, 178u8, 118u8, 15u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::Uint(8usize)], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { specialization: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self .specialization .clone() .to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), ))]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result<[u8; 32usize], String> { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result<[u8; 32usize], String> { let mut values = ethabi::decode(&[ethabi::ParamType::FixedBytes(32usize)], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok({ let mut result = [0u8; 32]; let v = values .pop() .expect("one output data should have existed") .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option<[u8; 32usize]> { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for RegisterPool { const NAME: &'static str = "registerPool"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable<[u8; 32usize]> for RegisterPool { fn output(data: &[u8]) -> Result<[u8; 32usize], String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct RegisterTokens { pub pool_id: [u8; 32usize], pub tokens: Vec>, pub asset_managers: Vec>, } impl RegisterTokens { const METHOD_ID: [u8; 4] = [102u8, 169u8, 199u8, 210u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = values .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), asset_managers: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::FixedBytes(self.pool_id.as_ref().to_vec()), { let v = self .tokens .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, { let v = self .asset_managers .iter() .map(|inner| ethabi::Token::Address(ethabi::Address::from_slice(&inner))) .collect(); ethabi::Token::Array(v) }, ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for RegisterTokens { const NAME: &'static str = "registerTokens"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct SetAuthorizer { pub new_authorizer: Vec, } impl SetAuthorizer { const METHOD_ID: [u8; 4] = [5u8, 138u8, 98u8, 143u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::Address], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { new_authorizer: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::Address(ethabi::Address::from_slice( &self.new_authorizer, ))]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for SetAuthorizer { const NAME: &'static str = "setAuthorizer"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct SetPaused { pub paused: bool, } impl SetPaused { const METHOD_ID: [u8; 4] = [22u8, 195u8, 139u8, 60u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode(&[ethabi::ParamType::Bool], maybe_data.unwrap()) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { paused: values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ethabi::Token::Bool(self.paused.clone())]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for SetPaused { const NAME: &'static str = "setPaused"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct SetRelayerApproval { pub sender: Vec, pub relayer: Vec, pub approved: bool, } impl SetRelayerApproval { const METHOD_ID: [u8; 4] = [250u8, 110u8, 103u8, 29u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ethabi::ParamType::Address, ethabi::ParamType::Address, ethabi::ParamType::Bool], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { sender: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), relayer: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), approved: values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Address(ethabi::Address::from_slice(&self.sender)), ethabi::Token::Address(ethabi::Address::from_slice(&self.relayer)), ethabi::Token::Bool(self.approved.clone()), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } } impl substreams_ethereum::Function for SetRelayerApproval { const NAME: &'static str = "setRelayerApproval"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } #[derive(Debug, Clone, PartialEq)] pub struct Swap { pub single_swap: ( [u8; 32usize], substreams::scalar::BigInt, Vec, Vec, substreams::scalar::BigInt, Vec, ), pub funds: (Vec, bool, Vec, bool), pub limit: substreams::scalar::BigInt, pub deadline: substreams::scalar::BigInt, } impl Swap { const METHOD_ID: [u8; 4] = [82u8, 187u8, 190u8, 41u8]; pub fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { let maybe_data = call.input.get(4..); if maybe_data.is_none() { return Err("no data to decode".to_string()); } let mut values = ethabi::decode( &[ ethabi::ParamType::Tuple(vec![ ethabi::ParamType::FixedBytes(32usize), ethabi::ParamType::Uint(8usize), ethabi::ParamType::Address, ethabi::ParamType::Address, ethabi::ParamType::Uint(256usize), ethabi::ParamType::Bytes, ]), ethabi::ParamType::Tuple(vec![ ethabi::ParamType::Address, ethabi::ParamType::Bool, ethabi::ParamType::Address, ethabi::ParamType::Bool, ]), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { single_swap: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( { let mut result = [0u8; 32]; let v = tuple_elements[0usize] .clone() .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, { let mut v = [0 as u8; 32]; tuple_elements[1usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[2usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[3usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), { let mut v = [0 as u8; 32]; tuple_elements[4usize] .clone() .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, tuple_elements[5usize] .clone() .into_bytes() .expect(INTERNAL_ERR), ) }, funds: { let tuple_elements = values .pop() .expect(INTERNAL_ERR) .into_tuple() .expect(INTERNAL_ERR); ( tuple_elements[0usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[1usize] .clone() .into_bool() .expect(INTERNAL_ERR), tuple_elements[2usize] .clone() .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tuple_elements[3usize] .clone() .into_bool() .expect(INTERNAL_ERR), ) }, limit: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, deadline: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode(&[ ethabi::Token::Tuple(vec![ ethabi::Token::FixedBytes(self.single_swap.0.as_ref().to_vec()), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.single_swap.1.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Address(ethabi::Address::from_slice(&self.single_swap.2)), ethabi::Token::Address(ethabi::Address::from_slice(&self.single_swap.3)), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.single_swap.4.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Bytes(self.single_swap.5.clone()), ]), ethabi::Token::Tuple(vec![ ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.0)), ethabi::Token::Bool(self.funds.1.clone()), ethabi::Token::Address(ethabi::Address::from_slice(&self.funds.2)), ethabi::Token::Bool(self.funds.3.clone()), ]), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.limit.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ethabi::Token::Uint(ethabi::Uint::from_big_endian( match self.deadline.clone().to_bytes_be() { (num_bigint::Sign::Plus, bytes) => bytes, (num_bigint::Sign::NoSign, bytes) => bytes, (num_bigint::Sign::Minus, _) => { panic!("negative numbers are not supported") } } .as_slice(), )), ]); let mut encoded = Vec::with_capacity(4 + data.len()); encoded.extend(Self::METHOD_ID); encoded.extend(data); encoded } pub fn output_call( call: &substreams_ethereum::pb::eth::v2::Call, ) -> Result { Self::output(call.return_data.as_ref()) } pub fn output(data: &[u8]) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Uint(256usize)], data.as_ref()) .map_err(|e| format!("unable to decode output data: {:?}", e))?; Ok({ let mut v = [0 as u8; 32]; values .pop() .expect("one output data should have existed") .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) } pub fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { match call.input.get(0..4) { Some(signature) => Self::METHOD_ID == signature, None => false, } } pub fn call(&self, address: Vec) -> Option { use substreams_ethereum::pb::eth::rpc; let rpc_calls = rpc::RpcCalls { calls: vec![rpc::RpcCall { to_addr: address, data: self.encode() }], }; let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses; let response = responses .get(0) .expect("one response should have existed"); if response.failed { return None; } match Self::output(response.raw.as_ref()) { Ok(data) => Some(data), Err(err) => { use substreams_ethereum::Function; substreams::log::info!( "Call output for function `{}` failed to decode with error: {}", Self::NAME, err ); None } } } } impl substreams_ethereum::Function for Swap { const NAME: &'static str = "swap"; fn match_call(call: &substreams_ethereum::pb::eth::v2::Call) -> bool { Self::match_call(call) } fn decode(call: &substreams_ethereum::pb::eth::v2::Call) -> Result { Self::decode(call) } fn encode(&self) -> Vec { self.encode() } } impl substreams_ethereum::rpc::RPCDecodable for Swap { fn output(data: &[u8]) -> Result { Self::output(data) } } } /// Contract's events. #[allow(dead_code, unused_imports, unused_variables)] pub mod events { use super::INTERNAL_ERR; #[derive(Debug, Clone, PartialEq)] pub struct AuthorizerChanged { pub new_authorizer: Vec, } impl AuthorizerChanged { const TOPIC_ID: [u8; 32] = [ 148u8, 185u8, 121u8, 182u8, 131u8, 26u8, 81u8, 41u8, 62u8, 38u8, 65u8, 66u8, 111u8, 151u8, 116u8, 127u8, 238u8, 212u8, 111u8, 23u8, 119u8, 159u8, 237u8, 156u8, 209u8, 141u8, 30u8, 206u8, 252u8, 254u8, 146u8, 239u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() != 0usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Ok(Self { new_authorizer: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'new_authorizer' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } } impl substreams_ethereum::Event for AuthorizerChanged { const NAME: &'static str = "AuthorizerChanged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct ExternalBalanceTransfer { pub token: Vec, pub sender: Vec, pub recipient: Vec, pub amount: substreams::scalar::BigInt, } impl ExternalBalanceTransfer { const TOPIC_ID: [u8; 32] = [ 84u8, 10u8, 26u8, 63u8, 40u8, 52u8, 12u8, 174u8, 195u8, 54u8, 200u8, 29u8, 141u8, 123u8, 61u8, 241u8, 57u8, 238u8, 92u8, 220u8, 24u8, 57u8, 164u8, 242u8, 131u8, 215u8, 235u8, 183u8, 234u8, 174u8, 45u8, 92u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() != 64usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ethabi::ParamType::Address, ethabi::ParamType::Uint(256usize)], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { token: ethabi::decode(&[ethabi::ParamType::Address], log.topics[1usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'token' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), sender: ethabi::decode(&[ethabi::ParamType::Address], log.topics[2usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'sender' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), recipient: values .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), amount: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for ExternalBalanceTransfer { const NAME: &'static str = "ExternalBalanceTransfer"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct FlashLoan { pub recipient: Vec, pub token: Vec, pub amount: substreams::scalar::BigInt, pub fee_amount: substreams::scalar::BigInt, } impl FlashLoan { const TOPIC_ID: [u8; 32] = [ 13u8, 125u8, 117u8, 224u8, 26u8, 185u8, 87u8, 128u8, 211u8, 205u8, 28u8, 142u8, 192u8, 221u8, 108u8, 44u8, 225u8, 158u8, 58u8, 32u8, 66u8, 126u8, 236u8, 139u8, 245u8, 50u8, 131u8, 182u8, 251u8, 142u8, 149u8, 240u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() != 64usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize)], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { recipient: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'recipient' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token: ethabi::decode(&[ethabi::ParamType::Address], log.topics[2usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'token' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), amount: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, fee_amount: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for FlashLoan { const NAME: &'static str = "FlashLoan"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct InternalBalanceChanged { pub user: Vec, pub token: Vec, pub delta: substreams::scalar::BigInt, } impl InternalBalanceChanged { const TOPIC_ID: [u8; 32] = [ 24u8, 225u8, 234u8, 65u8, 57u8, 230u8, 132u8, 19u8, 215u8, 208u8, 138u8, 167u8, 82u8, 231u8, 21u8, 104u8, 227u8, 107u8, 44u8, 91u8, 249u8, 64u8, 137u8, 51u8, 20u8, 194u8, 197u8, 176u8, 30u8, 170u8, 12u8, 66u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() != 32usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Int(256usize)], log.data.as_ref()) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { user: ethabi::decode(&[ethabi::ParamType::Address], log.topics[1usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'user' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token: ethabi::decode(&[ethabi::ParamType::Address], log.topics[2usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'token' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), delta: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for InternalBalanceChanged { const NAME: &'static str = "InternalBalanceChanged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct PausedStateChanged { pub paused: bool, } impl PausedStateChanged { const TOPIC_ID: [u8; 32] = [ 158u8, 58u8, 94u8, 55u8, 34u8, 69u8, 50u8, 222u8, 166u8, 123u8, 137u8, 250u8, 206u8, 24u8, 87u8, 3u8, 115u8, 138u8, 34u8, 138u8, 110u8, 138u8, 35u8, 222u8, 229u8, 70u8, 150u8, 1u8, 128u8, 211u8, 190u8, 100u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 1usize { return false; } if log.data.len() != 32usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Bool], log.data.as_ref()) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { paused: values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), }) } } impl substreams_ethereum::Event for PausedStateChanged { const NAME: &'static str = "PausedStateChanged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct PoolBalanceChanged { pub pool_id: [u8; 32usize], pub liquidity_provider: Vec, pub tokens: Vec>, pub deltas: Vec, pub protocol_fee_amounts: Vec, } impl PoolBalanceChanged { const TOPIC_ID: [u8; 32] = [ 229u8, 206u8, 36u8, 144u8, 135u8, 206u8, 4u8, 240u8, 90u8, 149u8, 113u8, 146u8, 67u8, 84u8, 0u8, 253u8, 151u8, 134u8, 141u8, 186u8, 14u8, 106u8, 75u8, 76u8, 4u8, 154u8, 191u8, 138u8, 248u8, 13u8, 174u8, 120u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() < 192usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Int(256usize))), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Uint(256usize))), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, liquidity_provider: ethabi::decode( &[ethabi::ParamType::Address], log.topics[2usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'liquidity_provider' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner.into_address().expect(INTERNAL_ERR).as_bytes().to_vec() }) .collect(), deltas: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }) .collect(), protocol_fee_amounts: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { let mut v = [0 as u8; 32]; inner .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }) .collect(), }) } } impl substreams_ethereum::Event for PoolBalanceChanged { const NAME: &'static str = "PoolBalanceChanged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct PoolBalanceManaged { pub pool_id: [u8; 32usize], pub asset_manager: Vec, pub token: Vec, pub cash_delta: substreams::scalar::BigInt, pub managed_delta: substreams::scalar::BigInt, } impl PoolBalanceManaged { const TOPIC_ID: [u8; 32] = [ 110u8, 220u8, 175u8, 98u8, 65u8, 16u8, 91u8, 76u8, 148u8, 194u8, 239u8, 219u8, 243u8, 166u8, 177u8, 36u8, 88u8, 235u8, 61u8, 7u8, 190u8, 58u8, 14u8, 129u8, 210u8, 75u8, 19u8, 196u8, 64u8, 69u8, 254u8, 122u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 4usize { return false; } if log.data.len() != 64usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ethabi::ParamType::Int(256usize), ethabi::ParamType::Int(256usize)], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, asset_manager: ethabi::decode( &[ethabi::ParamType::Address], log.topics[2usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'asset_manager' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token: ethabi::decode(&[ethabi::ParamType::Address], log.topics[3usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'token' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), cash_delta: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }, managed_delta: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_int() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_signed_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for PoolBalanceManaged { const NAME: &'static str = "PoolBalanceManaged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct PoolRegistered { pub pool_id: [u8; 32usize], pub pool_address: Vec, pub specialization: substreams::scalar::BigInt, } impl PoolRegistered { const TOPIC_ID: [u8; 32] = [ 60u8, 19u8, 188u8, 48u8, 184u8, 232u8, 120u8, 197u8, 63u8, 210u8, 163u8, 107u8, 103u8, 148u8, 9u8, 192u8, 115u8, 175u8, 215u8, 89u8, 80u8, 190u8, 67u8, 216u8, 133u8, 135u8, 104u8, 233u8, 86u8, 251u8, 194u8, 14u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() != 32usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Uint(8usize)], log.data.as_ref()) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, pool_address: ethabi::decode( &[ethabi::ParamType::Address], log.topics[2usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_address' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), specialization: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for PoolRegistered { const NAME: &'static str = "PoolRegistered"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct RelayerApprovalChanged { pub relayer: Vec, pub sender: Vec, pub approved: bool, } impl RelayerApprovalChanged { const TOPIC_ID: [u8; 32] = [ 70u8, 150u8, 31u8, 219u8, 69u8, 2u8, 182u8, 70u8, 213u8, 9u8, 95u8, 186u8, 118u8, 0u8, 72u8, 106u8, 138u8, 192u8, 80u8, 65u8, 213u8, 92u8, 223u8, 15u8, 22u8, 237u8, 103u8, 113u8, 128u8, 181u8, 202u8, 216u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { return false; } if log.data.len() != 32usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode(&[ethabi::ParamType::Bool], log.data.as_ref()) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { relayer: ethabi::decode(&[ethabi::ParamType::Address], log.topics[1usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'relayer' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), sender: ethabi::decode(&[ethabi::ParamType::Address], log.topics[2usize].as_ref()) .map_err(|e| { format!( "unable to decode param 'sender' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), approved: values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), }) } } impl substreams_ethereum::Event for RelayerApprovalChanged { const NAME: &'static str = "RelayerApprovalChanged"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct Swap { pub pool_id: [u8; 32usize], pub token_in: Vec, pub token_out: Vec, pub amount_in: substreams::scalar::BigInt, pub amount_out: substreams::scalar::BigInt, } impl Swap { const TOPIC_ID: [u8; 32] = [ 33u8, 112u8, 199u8, 65u8, 196u8, 21u8, 49u8, 174u8, 194u8, 14u8, 124u8, 16u8, 124u8, 36u8, 238u8, 207u8, 221u8, 21u8, 230u8, 156u8, 155u8, 176u8, 168u8, 221u8, 55u8, 177u8, 132u8, 11u8, 158u8, 11u8, 32u8, 123u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 4usize { return false; } if log.data.len() != 64usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ethabi::ParamType::Uint(256usize), ethabi::ParamType::Uint(256usize)], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, token_in: ethabi::decode( &[ethabi::ParamType::Address], log.topics[2usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'token_in' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token_out: ethabi::decode( &[ethabi::ParamType::Address], log.topics[3usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'token_out' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), amount_in: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, amount_out: { let mut v = [0 as u8; 32]; values .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, }) } } impl substreams_ethereum::Event for Swap { const NAME: &'static str = "Swap"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct TokensDeregistered { pub pool_id: [u8; 32usize], pub tokens: Vec>, } impl TokensDeregistered { const TOPIC_ID: [u8; 32] = [ 125u8, 205u8, 198u8, 208u8, 46u8, 244u8, 12u8, 124u8, 26u8, 112u8, 70u8, 160u8, 17u8, 176u8, 88u8, 189u8, 127u8, 152u8, 143u8, 161u8, 78u8, 32u8, 166u8, 99u8, 68u8, 249u8, 212u8, 230u8, 6u8, 87u8, 214u8, 16u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() < 64usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address))], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), }) } } impl substreams_ethereum::Event for TokensDeregistered { const NAME: &'static str = "TokensDeregistered"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } #[derive(Debug, Clone, PartialEq)] pub struct TokensRegistered { pub pool_id: [u8; 32usize], pub tokens: Vec>, pub asset_managers: Vec>, } impl TokensRegistered { const TOPIC_ID: [u8; 32] = [ 245u8, 132u8, 125u8, 63u8, 33u8, 151u8, 177u8, 108u8, 220u8, 210u8, 9u8, 142u8, 201u8, 93u8, 9u8, 5u8, 205u8, 26u8, 189u8, 175u8, 65u8, 95u8, 7u8, 187u8, 124u8, 239u8, 43u8, 186u8, 138u8, 197u8, 222u8, 196u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() < 128usize { return false; } return log .topics .get(0) .expect("bounds already checked") .as_ref() == Self::TOPIC_ID; } pub fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { let mut values = ethabi::decode( &[ ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ethabi::ParamType::Array(Box::new(ethabi::ParamType::Address)), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { pool_id: { let mut result = [0u8; 32]; let v = ethabi::decode( &[ethabi::ParamType::FixedBytes(32usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'pool_id' from topic of type 'bytes32': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_fixed_bytes() .expect(INTERNAL_ERR); result.copy_from_slice(&v); result }, tokens: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), asset_managers: values .pop() .expect(INTERNAL_ERR) .into_array() .expect(INTERNAL_ERR) .into_iter() .map(|inner| { inner .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec() }) .collect(), }) } } impl substreams_ethereum::Event for TokensRegistered { const NAME: &'static str = "TokensRegistered"; fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { Self::match_log(log) } fn decode(log: &substreams_ethereum::pb::eth::v2::Log) -> Result { Self::decode(log) } } }