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 A {} impl A { const METHOD_ID: [u8; 4] = [244u8, 70u8, 193u8, 208u8]; 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 { 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 A { const NAME: &'static str = "A"; 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 A { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct AddLiquidity { pub amounts: [substreams::scalar::BigInt; 3usize], pub min_mint_amount: substreams::scalar::BigInt, } impl AddLiquidity { const METHOD_ID: [u8; 4] = [69u8, 21u8, 206u8, 243u8]; 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, min_mint_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) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ { 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::FixedArray(v) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.min_mint_amount.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 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 AddLiquidity { const NAME: &'static str = "add_liquidity"; 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 AdminActionsDeadline {} impl AdminActionsDeadline { const METHOD_ID: [u8; 4] = [64u8, 94u8, 40u8, 248u8]; 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 { 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 AdminActionsDeadline { const NAME: &'static str = "admin_actions_deadline"; 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 AdminActionsDeadline { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct AdminBalances { pub i: substreams::scalar::BigInt, } impl AdminBalances { const METHOD_ID: [u8; 4] = [226u8, 231u8, 210u8, 100u8]; 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(256usize)], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { i: { 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.i.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 AdminBalances { const NAME: &'static str = "admin_balances"; 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 AdminBalances { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct AdminFee {} impl AdminFee { const METHOD_ID: [u8; 4] = [254u8, 227u8, 247u8, 249u8]; 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 { 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 AdminFee { const NAME: &'static str = "admin_fee"; 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 AdminFee { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct ApplyNewFee {} impl ApplyNewFee { const METHOD_ID: [u8; 4] = [79u8, 18u8, 254u8, 151u8]; 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 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 ApplyNewFee { const NAME: &'static str = "apply_new_fee"; 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 ApplyTransferOwnership {} impl ApplyTransferOwnership { const METHOD_ID: [u8; 4] = [106u8, 28u8, 5u8, 174u8]; 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 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 ApplyTransferOwnership { const NAME: &'static str = "apply_transfer_ownership"; 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 Balances { pub arg0: substreams::scalar::BigInt, } impl Balances { const METHOD_ID: [u8; 4] = [73u8, 3u8, 176u8, 209u8]; 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(256usize)], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { arg0: { 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.arg0.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 Balances { const NAME: &'static str = "balances"; 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 Balances { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct CalcTokenAmount { pub amounts: [substreams::scalar::BigInt; 3usize], pub deposit: bool, } impl CalcTokenAmount { const METHOD_ID: [u8; 4] = [56u8, 131u8, 225u8, 25u8]; 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::Bool, ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, deposit: values .pop() .expect(INTERNAL_ERR) .into_bool() .expect(INTERNAL_ERR), }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ { 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::FixedArray(v) }, ethabi::Token::Bool(self.deposit.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 { 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 CalcTokenAmount { const NAME: &'static str = "calc_token_amount"; 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 CalcTokenAmount { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct CalcWithdrawOneCoin { pub token_amount: substreams::scalar::BigInt, pub i: substreams::scalar::BigInt, } impl CalcWithdrawOneCoin { const METHOD_ID: [u8; 4] = [204u8, 43u8, 39u8, 215u8]; 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(256usize), ethabi::ParamType::Int(128usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { token_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) }, i: { 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) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.token_amount.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 non_full_signed_bytes = self.i.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()), ) }, ], ); 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 CalcWithdrawOneCoin { const NAME: &'static str = "calc_withdraw_one_coin"; 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 CalcWithdrawOneCoin { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct Coins { pub arg0: substreams::scalar::BigInt, } impl Coins { const METHOD_ID: [u8; 4] = [198u8, 97u8, 6u8, 87u8]; 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(256usize)], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { arg0: { 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.arg0.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::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 Coins { const NAME: &'static str = "coins"; 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 Coins { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct CommitNewFee { pub new_fee: substreams::scalar::BigInt, pub new_admin_fee: substreams::scalar::BigInt, } impl CommitNewFee { const METHOD_ID: [u8; 4] = [91u8, 90u8, 20u8, 103u8]; 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(256usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { new_fee: { 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) }, new_admin_fee: { 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.new_fee.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.new_admin_fee.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 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 CommitNewFee { const NAME: &'static str = "commit_new_fee"; 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 CommitTransferOwnership { pub owner: Vec, } impl CommitTransferOwnership { const METHOD_ID: [u8; 4] = [107u8, 68u8, 26u8, 64u8]; 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 { owner: 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.owner))], ); 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 CommitTransferOwnership { const NAME: &'static str = "commit_transfer_ownership"; 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 DonateAdminFees {} impl DonateAdminFees { const METHOD_ID: [u8; 4] = [82u8, 76u8, 57u8, 1u8]; 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 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 DonateAdminFees { const NAME: &'static str = "donate_admin_fees"; 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 Exchange { pub i: substreams::scalar::BigInt, pub j: substreams::scalar::BigInt, pub dx: substreams::scalar::BigInt, pub min_dy: substreams::scalar::BigInt, } impl Exchange { const METHOD_ID: [u8; 4] = [61u8, 240u8, 33u8, 36u8]; 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::Int(128usize), ethabi::ParamType::Int(128usize), 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 { i: { 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) }, j: { 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) }, dx: { 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) }, min_dy: { 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( &[ { let non_full_signed_bytes = self.i.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()), ) }, { let non_full_signed_bytes = self.j.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()), ) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.dx.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.min_dy.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 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 Exchange { const NAME: &'static str = "exchange"; 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 Fee {} impl Fee { const METHOD_ID: [u8; 4] = [221u8, 202u8, 63u8, 67u8]; 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 { 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 Fee { const NAME: &'static str = "fee"; 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 Fee { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct FutureA {} impl FutureA { const METHOD_ID: [u8; 4] = [180u8, 181u8, 119u8, 173u8]; 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 { 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 FutureA { const NAME: &'static str = "future_A"; 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 FutureA { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct FutureATime {} impl FutureATime { const METHOD_ID: [u8; 4] = [20u8, 5u8, 34u8, 136u8]; 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 { 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 FutureATime { const NAME: &'static str = "future_A_time"; 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 FutureATime { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct FutureAdminFee {} impl FutureAdminFee { const METHOD_ID: [u8; 4] = [227u8, 130u8, 68u8, 98u8]; 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 { 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 FutureAdminFee { const NAME: &'static str = "future_admin_fee"; 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 FutureAdminFee { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct FutureFee {} impl FutureFee { const METHOD_ID: [u8; 4] = [88u8, 104u8, 13u8, 11u8]; 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 { 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 FutureFee { const NAME: &'static str = "future_fee"; 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 FutureFee { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct FutureOwner {} impl FutureOwner { const METHOD_ID: [u8; 4] = [30u8, 192u8, 205u8, 193u8]; 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 FutureOwner { const NAME: &'static str = "future_owner"; 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 FutureOwner { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetDy { pub i: substreams::scalar::BigInt, pub j: substreams::scalar::BigInt, pub dx: substreams::scalar::BigInt, } impl GetDy { const METHOD_ID: [u8; 4] = [94u8, 13u8, 68u8, 63u8]; 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::Int(128usize), ethabi::ParamType::Int(128usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { i: { 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) }, j: { 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) }, dx: { 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( &[ { let non_full_signed_bytes = self.i.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()), ) }, { let non_full_signed_bytes = self.j.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()), ) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.dx.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 GetDy { const NAME: &'static str = "get_dy"; 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 GetDy { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetDyUnderlying { pub i: substreams::scalar::BigInt, pub j: substreams::scalar::BigInt, pub dx: substreams::scalar::BigInt, } impl GetDyUnderlying { const METHOD_ID: [u8; 4] = [7u8, 33u8, 30u8, 247u8]; 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::Int(128usize), ethabi::ParamType::Int(128usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { i: { 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) }, j: { 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) }, dx: { 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( &[ { let non_full_signed_bytes = self.i.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()), ) }, { let non_full_signed_bytes = self.j.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()), ) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.dx.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 GetDyUnderlying { const NAME: &'static str = "get_dy_underlying"; 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 GetDyUnderlying { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct GetVirtualPrice {} impl GetVirtualPrice { const METHOD_ID: [u8; 4] = [187u8, 123u8, 139u8, 128u8]; 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 { 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 GetVirtualPrice { const NAME: &'static str = "get_virtual_price"; 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 GetVirtualPrice { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct InitialA {} impl InitialA { const METHOD_ID: [u8; 4] = [84u8, 9u8, 73u8, 26u8]; 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 { 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 InitialA { const NAME: &'static str = "initial_A"; 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 InitialA { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct InitialATime {} impl InitialATime { const METHOD_ID: [u8; 4] = [32u8, 129u8, 6u8, 108u8]; 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 { 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 InitialATime { const NAME: &'static str = "initial_A_time"; 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 InitialATime { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct KillMe {} impl KillMe { const METHOD_ID: [u8; 4] = [227u8, 105u8, 136u8, 83u8]; 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 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 KillMe { const NAME: &'static str = "kill_me"; 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 Owner {} impl Owner { const METHOD_ID: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; 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 Owner { const NAME: &'static str = "owner"; 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 Owner { fn output(data: &[u8]) -> Result, String> { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct RampA { pub future_a: substreams::scalar::BigInt, pub future_time: substreams::scalar::BigInt, } impl RampA { const METHOD_ID: [u8; 4] = [60u8, 21u8, 126u8, 100u8]; 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(256usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { future_a: { 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) }, future_time: { 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.future_a.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.future_time.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 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 RampA { const NAME: &'static str = "ramp_A"; 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 RemoveLiquidity { pub amount: substreams::scalar::BigInt, pub min_amounts: [substreams::scalar::BigInt; 3usize], } impl RemoveLiquidity { const METHOD_ID: [u8; 4] = [236u8, 181u8, 134u8, 165u8]; 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(256usize), ethabi::ParamType::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { 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) }, min_amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.amount.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 .min_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::FixedArray(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 RemoveLiquidity { const NAME: &'static str = "remove_liquidity"; 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 RemoveLiquidityImbalance { pub amounts: [substreams::scalar::BigInt; 3usize], pub max_burn_amount: substreams::scalar::BigInt, } impl RemoveLiquidityImbalance { const METHOD_ID: [u8; 4] = [159u8, 218u8, 234u8, 12u8]; 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, max_burn_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) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ { 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::FixedArray(v) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.max_burn_amount.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 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 RemoveLiquidityImbalance { const NAME: &'static str = "remove_liquidity_imbalance"; 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 RemoveLiquidityOneCoin { pub token_amount: substreams::scalar::BigInt, pub i: substreams::scalar::BigInt, pub min_amount: substreams::scalar::BigInt, } impl RemoveLiquidityOneCoin { const METHOD_ID: [u8; 4] = [26u8, 77u8, 1u8, 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::Uint(256usize), ethabi::ParamType::Int(128usize), ethabi::ParamType::Uint(256usize), ], maybe_data.unwrap(), ) .map_err(|e| format!("unable to decode call.input: {:?}", e))?; values.reverse(); Ok(Self { token_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) }, i: { 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) }, min_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) }, }) } pub fn encode(&self) -> Vec { let data = ethabi::encode( &[ ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.token_amount.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 non_full_signed_bytes = self.i.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()), ) }, ethabi::Token::Uint( ethabi::Uint::from_big_endian( match self.min_amount.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 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 RemoveLiquidityOneCoin { const NAME: &'static str = "remove_liquidity_one_coin"; 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 RevertNewParameters {} impl RevertNewParameters { const METHOD_ID: [u8; 4] = [34u8, 104u8, 64u8, 251u8]; 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 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 RevertNewParameters { const NAME: &'static str = "revert_new_parameters"; 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 RevertTransferOwnership {} impl RevertTransferOwnership { const METHOD_ID: [u8; 4] = [134u8, 251u8, 241u8, 147u8]; 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 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 RevertTransferOwnership { const NAME: &'static str = "revert_transfer_ownership"; 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 StopRampA {} impl StopRampA { const METHOD_ID: [u8; 4] = [85u8, 26u8, 101u8, 136u8]; 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 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 StopRampA { const NAME: &'static str = "stop_ramp_A"; 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 TransferOwnershipDeadline {} impl TransferOwnershipDeadline { const METHOD_ID: [u8; 4] = [224u8, 160u8, 181u8, 134u8]; 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 { 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 TransferOwnershipDeadline { const NAME: &'static str = "transfer_ownership_deadline"; 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 TransferOwnershipDeadline { fn output(data: &[u8]) -> Result { Self::output(data) } } #[derive(Debug, Clone, PartialEq)] pub struct UnkillMe {} impl UnkillMe { const METHOD_ID: [u8; 4] = [48u8, 70u8, 249u8, 114u8]; 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 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 UnkillMe { const NAME: &'static str = "unkill_me"; 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 WithdrawAdminFees {} impl WithdrawAdminFees { const METHOD_ID: [u8; 4] = [48u8, 197u8, 64u8, 133u8]; 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 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 WithdrawAdminFees { const NAME: &'static str = "withdraw_admin_fees"; 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() } } } /// Contract's events. #[allow(dead_code, unused_imports, unused_variables)] pub mod events { use super::INTERNAL_ERR; #[derive(Debug, Clone, PartialEq)] pub struct AddLiquidity { pub provider: Vec, pub token_amounts: [substreams::scalar::BigInt; 3usize], pub fees: [substreams::scalar::BigInt; 3usize], pub invariant: substreams::scalar::BigInt, pub token_supply: substreams::scalar::BigInt, } impl AddLiquidity { const TOPIC_ID: [u8; 32] = [ 66u8, 63u8, 100u8, 149u8, 160u8, 143u8, 198u8, 82u8, 66u8, 92u8, 244u8, 237u8, 13u8, 31u8, 158u8, 55u8, 229u8, 113u8, 217u8, 185u8, 82u8, 155u8, 28u8, 28u8, 35u8, 204u8, 231u8, 128u8, 178u8, 231u8, 223u8, 13u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() != 256usize { 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), 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 { provider: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'provider' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token_amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, fees: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, invariant: { 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) }, token_supply: { 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 AddLiquidity { const NAME: &'static str = "AddLiquidity"; 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 CommitNewAdmin { pub deadline: substreams::scalar::BigInt, pub admin: Vec, } impl CommitNewAdmin { const TOPIC_ID: [u8; 32] = [ 24u8, 26u8, 163u8, 170u8, 23u8, 212u8, 203u8, 249u8, 146u8, 101u8, 221u8, 68u8, 67u8, 235u8, 160u8, 9u8, 67u8, 61u8, 60u8, 222u8, 121u8, 214u8, 1u8, 100u8, 253u8, 225u8, 209u8, 161u8, 146u8, 190u8, 185u8, 53u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 3usize { 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 { deadline: { let mut v = [0 as u8; 32]; ethabi::decode( &[ethabi::ParamType::Uint(256usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'deadline' from topic of type 'uint256': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_uint() .expect(INTERNAL_ERR) .to_big_endian(v.as_mut_slice()); substreams::scalar::BigInt::from_unsigned_bytes_be(&v) }, admin: ethabi::decode( &[ethabi::ParamType::Address], log.topics[2usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'admin' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } } impl substreams_ethereum::Event for CommitNewAdmin { const NAME: &'static str = "CommitNewAdmin"; 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 CommitNewFee { pub deadline: substreams::scalar::BigInt, pub fee: substreams::scalar::BigInt, pub admin_fee: substreams::scalar::BigInt, } impl CommitNewFee { const TOPIC_ID: [u8; 32] = [ 53u8, 31u8, 197u8, 218u8, 47u8, 191u8, 72u8, 15u8, 34u8, 37u8, 222u8, 191u8, 54u8, 100u8, 164u8, 188u8, 144u8, 250u8, 153u8, 35u8, 116u8, 58u8, 173u8, 88u8, 180u8, 96u8, 63u8, 100u8, 142u8, 147u8, 31u8, 224u8, ]; 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::Uint(256usize), ethabi::ParamType::Uint(256usize), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { deadline: { let mut v = [0 as u8; 32]; ethabi::decode( &[ethabi::ParamType::Uint(256usize)], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'deadline' from topic of type 'uint256': {:?}", e ) })? .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: { 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) }, admin_fee: { 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 CommitNewFee { const NAME: &'static str = "CommitNewFee"; 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 NewAdmin { pub admin: Vec, } impl NewAdmin { const TOPIC_ID: [u8; 32] = [ 113u8, 97u8, 64u8, 113u8, 184u8, 141u8, 238u8, 94u8, 11u8, 42u8, 229u8, 120u8, 169u8, 221u8, 123u8, 46u8, 187u8, 233u8, 174u8, 131u8, 43u8, 164u8, 25u8, 220u8, 2u8, 66u8, 205u8, 6u8, 90u8, 41u8, 11u8, 108u8, ]; 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 { admin: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'admin' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), }) } } impl substreams_ethereum::Event for NewAdmin { const NAME: &'static str = "NewAdmin"; 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 NewFee { pub fee: substreams::scalar::BigInt, pub admin_fee: substreams::scalar::BigInt, } impl NewFee { const TOPIC_ID: [u8; 32] = [ 190u8, 18u8, 133u8, 155u8, 99u8, 106u8, 237u8, 96u8, 125u8, 82u8, 48u8, 178u8, 204u8, 39u8, 17u8, 246u8, 141u8, 112u8, 229u8, 16u8, 96u8, 230u8, 204u8, 161u8, 245u8, 117u8, 239u8, 93u8, 47u8, 204u8, 149u8, 209u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 1usize { 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 { fee: { 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) }, admin_fee: { 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 NewFee { const NAME: &'static str = "NewFee"; 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 RampA { pub old_a: substreams::scalar::BigInt, pub new_a: substreams::scalar::BigInt, pub initial_time: substreams::scalar::BigInt, pub future_time: substreams::scalar::BigInt, } impl RampA { const TOPIC_ID: [u8; 32] = [ 162u8, 183u8, 30u8, 198u8, 223u8, 148u8, 147u8, 0u8, 181u8, 154u8, 171u8, 54u8, 181u8, 94u8, 24u8, 150u8, 151u8, 183u8, 80u8, 17u8, 157u8, 211u8, 73u8, 252u8, 250u8, 140u8, 15u8, 119u8, 158u8, 131u8, 194u8, 84u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 1usize { 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::Uint(256usize), ethabi::ParamType::Uint(256usize), 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 { old_a: { 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) }, new_a: { 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) }, initial_time: { 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) }, future_time: { 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 RampA { const NAME: &'static str = "RampA"; 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 RemoveLiquidity { pub provider: Vec, pub token_amounts: [substreams::scalar::BigInt; 3usize], pub fees: [substreams::scalar::BigInt; 3usize], pub token_supply: substreams::scalar::BigInt, } impl RemoveLiquidity { const TOPIC_ID: [u8; 32] = [ 164u8, 157u8, 76u8, 240u8, 38u8, 86u8, 174u8, 191u8, 140u8, 119u8, 31u8, 90u8, 133u8, 133u8, 99u8, 138u8, 42u8, 21u8, 238u8, 108u8, 151u8, 207u8, 114u8, 5u8, 212u8, 32u8, 142u8, 215u8, 193u8, 223u8, 37u8, 45u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() != 224usize { 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::Uint(256usize), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { provider: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'provider' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token_amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, fees: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, token_supply: { 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 RemoveLiquidity { const NAME: &'static str = "RemoveLiquidity"; 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 RemoveLiquidityImbalance { pub provider: Vec, pub token_amounts: [substreams::scalar::BigInt; 3usize], pub fees: [substreams::scalar::BigInt; 3usize], pub invariant: substreams::scalar::BigInt, pub token_supply: substreams::scalar::BigInt, } impl RemoveLiquidityImbalance { const TOPIC_ID: [u8; 32] = [ 23u8, 53u8, 153u8, 219u8, 249u8, 198u8, 202u8, 111u8, 124u8, 59u8, 89u8, 13u8, 240u8, 122u8, 233u8, 138u8, 69u8, 215u8, 79u8, 245u8, 64u8, 101u8, 80u8, 81u8, 65u8, 231u8, 222u8, 108u8, 70u8, 166u8, 36u8, 194u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 2usize { return false; } if log.data.len() != 256usize { 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::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), ethabi::ParamType::FixedArray( Box::new(ethabi::ParamType::Uint(256usize)), 3usize, ), 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 { provider: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'provider' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token_amounts: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, fees: { let mut iter = values .pop() .expect(INTERNAL_ERR) .into_fixed_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) }); [ iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), iter.next().expect(INTERNAL_ERR), ] }, invariant: { 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) }, token_supply: { 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 RemoveLiquidityImbalance { const NAME: &'static str = "RemoveLiquidityImbalance"; 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 RemoveLiquidityOne { pub provider: Vec, pub token_amount: substreams::scalar::BigInt, pub coin_amount: substreams::scalar::BigInt, } impl RemoveLiquidityOne { const TOPIC_ID: [u8; 32] = [ 158u8, 150u8, 221u8, 59u8, 153u8, 122u8, 42u8, 37u8, 126u8, 236u8, 77u8, 249u8, 187u8, 110u8, 175u8, 98u8, 110u8, 32u8, 109u8, 245u8, 245u8, 67u8, 189u8, 150u8, 54u8, 130u8, 209u8, 67u8, 48u8, 11u8, 227u8, 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::Uint(256usize), ethabi::ParamType::Uint(256usize), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { provider: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'provider' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), token_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) }, coin_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 RemoveLiquidityOne { const NAME: &'static str = "RemoveLiquidityOne"; 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 StopRampA { pub a: substreams::scalar::BigInt, pub t: substreams::scalar::BigInt, } impl StopRampA { const TOPIC_ID: [u8; 32] = [ 70u8, 226u8, 47u8, 179u8, 112u8, 154u8, 210u8, 137u8, 246u8, 44u8, 230u8, 61u8, 70u8, 146u8, 72u8, 83u8, 109u8, 188u8, 120u8, 216u8, 43u8, 132u8, 163u8, 215u8, 231u8, 74u8, 214u8, 6u8, 220u8, 32u8, 25u8, 56u8, ]; pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool { if log.topics.len() != 1usize { 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 { a: { 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) }, t: { 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 StopRampA { const NAME: &'static str = "StopRampA"; 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 TokenExchange { pub buyer: Vec, pub sold_id: substreams::scalar::BigInt, pub tokens_sold: substreams::scalar::BigInt, pub bought_id: substreams::scalar::BigInt, pub tokens_bought: substreams::scalar::BigInt, } impl TokenExchange { const TOPIC_ID: [u8; 32] = [ 139u8, 62u8, 150u8, 242u8, 184u8, 137u8, 250u8, 119u8, 28u8, 83u8, 201u8, 129u8, 180u8, 13u8, 175u8, 0u8, 95u8, 99u8, 246u8, 55u8, 241u8, 134u8, 159u8, 112u8, 112u8, 82u8, 209u8, 90u8, 61u8, 217u8, 113u8, 64u8, ]; 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::Int(128usize), ethabi::ParamType::Uint(256usize), ethabi::ParamType::Int(128usize), ethabi::ParamType::Uint(256usize), ], log.data.as_ref(), ) .map_err(|e| format!("unable to decode log.data: {:?}", e))?; values.reverse(); Ok(Self { buyer: ethabi::decode( &[ethabi::ParamType::Address], log.topics[1usize].as_ref(), ) .map_err(|e| { format!( "unable to decode param 'buyer' from topic of type 'address': {:?}", e ) })? .pop() .expect(INTERNAL_ERR) .into_address() .expect(INTERNAL_ERR) .as_bytes() .to_vec(), sold_id: { 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) }, tokens_sold: { 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) }, bought_id: { 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) }, tokens_bought: { 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 TokenExchange { const NAME: &'static str = "TokenExchange"; 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) } } }