feat(substreams): add substreams for Uniswap v2 and v3
This commit is contained in:
zizou
904
substreams/ethereum-uniswap-v2/src/abi/factory.rs
Normal file
904
substreams/ethereum-uniswap-v2/src/abi/factory.rs
Normal file
@@ -0,0 +1,904 @@
|
||||
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 AllPairs {
|
||||
pub param0: substreams::scalar::BigInt,
|
||||
}
|
||||
impl AllPairs {
|
||||
const METHOD_ID: [u8; 4] = [30u8, 61u8, 209u8, 139u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
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 {
|
||||
param0: {
|
||||
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<u8> {
|
||||
let data = ethabi::encode(
|
||||
&[
|
||||
ethabi::Token::Uint(
|
||||
ethabi::Uint::from_big_endian(
|
||||
match self.param0.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<Vec<u8>, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<Vec<u8>, 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<u8>) -> Option<Vec<u8>> {
|
||||
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 AllPairs {
|
||||
const NAME: &'static str = "allPairs";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for AllPairs {
|
||||
fn output(data: &[u8]) -> Result<Vec<u8>, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct AllPairsLength {}
|
||||
impl AllPairsLength {
|
||||
const METHOD_ID: [u8; 4] = [87u8, 79u8, 43u8, 163u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
Ok(Self {})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
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<substreams::scalar::BigInt, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
||||
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<u8>) -> Option<substreams::scalar::BigInt> {
|
||||
use substreams_ethereum::pb::eth::rpc;
|
||||
let rpc_calls = rpc::RpcCalls {
|
||||
calls: vec![
|
||||
rpc::RpcCall { to_addr : address, data : self.encode(), }
|
||||
],
|
||||
};
|
||||
let responses = substreams_ethereum::rpc::eth_call(&rpc_calls).responses;
|
||||
let response = responses
|
||||
.get(0)
|
||||
.expect("one response should have existed");
|
||||
if response.failed {
|
||||
return None;
|
||||
}
|
||||
match Self::output(response.raw.as_ref()) {
|
||||
Ok(data) => Some(data),
|
||||
Err(err) => {
|
||||
use substreams_ethereum::Function;
|
||||
substreams::log::info!(
|
||||
"Call output for function `{}` failed to decode with error: {}",
|
||||
Self::NAME, err
|
||||
);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::Function for AllPairsLength {
|
||||
const NAME: &'static str = "allPairsLength";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
||||
for AllPairsLength {
|
||||
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct CreatePair {
|
||||
pub token_a: Vec<u8>,
|
||||
pub token_b: Vec<u8>,
|
||||
}
|
||||
impl CreatePair {
|
||||
const METHOD_ID: [u8; 4] = [201u8, 198u8, 83u8, 150u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
let maybe_data = call.input.get(4..);
|
||||
if maybe_data.is_none() {
|
||||
return Err("no data to decode".to_string());
|
||||
}
|
||||
let mut values = ethabi::decode(
|
||||
&[ethabi::ParamType::Address, ethabi::ParamType::Address],
|
||||
maybe_data.unwrap(),
|
||||
)
|
||||
.map_err(|e| format!("unable to decode call.input: {:?}", e))?;
|
||||
values.reverse();
|
||||
Ok(Self {
|
||||
token_a: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
token_b: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let data = ethabi::encode(
|
||||
&[
|
||||
ethabi::Token::Address(
|
||||
ethabi::Address::from_slice(&self.token_a),
|
||||
),
|
||||
ethabi::Token::Address(
|
||||
ethabi::Address::from_slice(&self.token_b),
|
||||
),
|
||||
],
|
||||
);
|
||||
let mut encoded = Vec::with_capacity(4 + data.len());
|
||||
encoded.extend(Self::METHOD_ID);
|
||||
encoded.extend(data);
|
||||
encoded
|
||||
}
|
||||
pub fn output_call(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Vec<u8>, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<Vec<u8>, 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<u8>) -> Option<Vec<u8>> {
|
||||
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 CreatePair {
|
||||
const NAME: &'static str = "createPair";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for CreatePair {
|
||||
fn output(data: &[u8]) -> Result<Vec<u8>, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct FeeTo {}
|
||||
impl FeeTo {
|
||||
const METHOD_ID: [u8; 4] = [1u8, 126u8, 126u8, 88u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
Ok(Self {})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
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<Vec<u8>, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<Vec<u8>, 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<u8>) -> Option<Vec<u8>> {
|
||||
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 FeeTo {
|
||||
const NAME: &'static str = "feeTo";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for FeeTo {
|
||||
fn output(data: &[u8]) -> Result<Vec<u8>, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct FeeToSetter {}
|
||||
impl FeeToSetter {
|
||||
const METHOD_ID: [u8; 4] = [9u8, 75u8, 116u8, 21u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
Ok(Self {})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
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<Vec<u8>, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<Vec<u8>, 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<u8>) -> Option<Vec<u8>> {
|
||||
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 FeeToSetter {
|
||||
const NAME: &'static str = "feeToSetter";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for FeeToSetter {
|
||||
fn output(data: &[u8]) -> Result<Vec<u8>, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct GetPair {
|
||||
pub param0: Vec<u8>,
|
||||
pub param1: Vec<u8>,
|
||||
}
|
||||
impl GetPair {
|
||||
const METHOD_ID: [u8; 4] = [230u8, 164u8, 57u8, 5u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
let maybe_data = call.input.get(4..);
|
||||
if maybe_data.is_none() {
|
||||
return Err("no data to decode".to_string());
|
||||
}
|
||||
let mut values = ethabi::decode(
|
||||
&[ethabi::ParamType::Address, ethabi::ParamType::Address],
|
||||
maybe_data.unwrap(),
|
||||
)
|
||||
.map_err(|e| format!("unable to decode call.input: {:?}", e))?;
|
||||
values.reverse();
|
||||
Ok(Self {
|
||||
param0: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
param1: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let data = ethabi::encode(
|
||||
&[
|
||||
ethabi::Token::Address(
|
||||
ethabi::Address::from_slice(&self.param0),
|
||||
),
|
||||
ethabi::Token::Address(ethabi::Address::from_slice(&self.param1)),
|
||||
],
|
||||
);
|
||||
let mut encoded = Vec::with_capacity(4 + data.len());
|
||||
encoded.extend(Self::METHOD_ID);
|
||||
encoded.extend(data);
|
||||
encoded
|
||||
}
|
||||
pub fn output_call(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Vec<u8>, String> {
|
||||
Self::output(call.return_data.as_ref())
|
||||
}
|
||||
pub fn output(data: &[u8]) -> Result<Vec<u8>, 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<u8>) -> Option<Vec<u8>> {
|
||||
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 GetPair {
|
||||
const NAME: &'static str = "getPair";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for GetPair {
|
||||
fn output(data: &[u8]) -> Result<Vec<u8>, String> {
|
||||
Self::output(data)
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct SetFeeTo {
|
||||
pub fee_to: Vec<u8>,
|
||||
}
|
||||
impl SetFeeTo {
|
||||
const METHOD_ID: [u8; 4] = [244u8, 105u8, 1u8, 237u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
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 {
|
||||
fee_to: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let data = ethabi::encode(
|
||||
&[ethabi::Token::Address(ethabi::Address::from_slice(&self.fee_to))],
|
||||
);
|
||||
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 SetFeeTo {
|
||||
const NAME: &'static str = "setFeeTo";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
self.encode()
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct SetFeeToSetter {
|
||||
pub fee_to_setter: Vec<u8>,
|
||||
}
|
||||
impl SetFeeToSetter {
|
||||
const METHOD_ID: [u8; 4] = [162u8, 231u8, 74u8, 246u8];
|
||||
pub fn decode(
|
||||
call: &substreams_ethereum::pb::eth::v2::Call,
|
||||
) -> Result<Self, String> {
|
||||
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 {
|
||||
fee_to_setter: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
})
|
||||
}
|
||||
pub fn encode(&self) -> Vec<u8> {
|
||||
let data = ethabi::encode(
|
||||
&[
|
||||
ethabi::Token::Address(
|
||||
ethabi::Address::from_slice(&self.fee_to_setter),
|
||||
),
|
||||
],
|
||||
);
|
||||
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 SetFeeToSetter {
|
||||
const NAME: &'static str = "setFeeToSetter";
|
||||
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, String> {
|
||||
Self::decode(call)
|
||||
}
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
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 PairCreated {
|
||||
pub token0: Vec<u8>,
|
||||
pub token1: Vec<u8>,
|
||||
pub pair: Vec<u8>,
|
||||
pub param3: substreams::scalar::BigInt,
|
||||
}
|
||||
impl PairCreated {
|
||||
const TOPIC_ID: [u8; 32] = [
|
||||
13u8,
|
||||
54u8,
|
||||
72u8,
|
||||
189u8,
|
||||
15u8,
|
||||
107u8,
|
||||
168u8,
|
||||
1u8,
|
||||
52u8,
|
||||
163u8,
|
||||
59u8,
|
||||
169u8,
|
||||
39u8,
|
||||
90u8,
|
||||
197u8,
|
||||
133u8,
|
||||
217u8,
|
||||
211u8,
|
||||
21u8,
|
||||
240u8,
|
||||
173u8,
|
||||
131u8,
|
||||
85u8,
|
||||
205u8,
|
||||
222u8,
|
||||
253u8,
|
||||
227u8,
|
||||
26u8,
|
||||
250u8,
|
||||
40u8,
|
||||
208u8,
|
||||
233u8,
|
||||
];
|
||||
pub fn match_log(log: &substreams_ethereum::pb::eth::v2::Log) -> bool {
|
||||
if log.topics.len() != 3usize {
|
||||
return false;
|
||||
}
|
||||
if log.data.len() != 64usize {
|
||||
return false;
|
||||
}
|
||||
return log.topics.get(0).expect("bounds already checked").as_ref()
|
||||
== Self::TOPIC_ID;
|
||||
}
|
||||
pub fn decode(
|
||||
log: &substreams_ethereum::pb::eth::v2::Log,
|
||||
) -> Result<Self, String> {
|
||||
let mut values = ethabi::decode(
|
||||
&[ethabi::ParamType::Address, ethabi::ParamType::Uint(256usize)],
|
||||
log.data.as_ref(),
|
||||
)
|
||||
.map_err(|e| format!("unable to decode log.data: {:?}", e))?;
|
||||
values.reverse();
|
||||
Ok(Self {
|
||||
token0: ethabi::decode(
|
||||
&[ethabi::ParamType::Address],
|
||||
log.topics[1usize].as_ref(),
|
||||
)
|
||||
.map_err(|e| {
|
||||
format!(
|
||||
"unable to decode param 'token0' from topic of type 'address': {:?}",
|
||||
e
|
||||
)
|
||||
})?
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
token1: ethabi::decode(
|
||||
&[ethabi::ParamType::Address],
|
||||
log.topics[2usize].as_ref(),
|
||||
)
|
||||
.map_err(|e| {
|
||||
format!(
|
||||
"unable to decode param 'token1' from topic of type 'address': {:?}",
|
||||
e
|
||||
)
|
||||
})?
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
pair: values
|
||||
.pop()
|
||||
.expect(INTERNAL_ERR)
|
||||
.into_address()
|
||||
.expect(INTERNAL_ERR)
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
param3: {
|
||||
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 PairCreated {
|
||||
const NAME: &'static str = "PairCreated";
|
||||
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, String> {
|
||||
Self::decode(log)
|
||||
}
|
||||
}
|
||||
}
|
||||
4
substreams/ethereum-uniswap-v2/src/abi/mod.rs
Normal file
4
substreams/ethereum-uniswap-v2/src/abi/mod.rs
Normal file
@@ -0,0 +1,4 @@
|
||||
#![allow(clippy::all, clippy::pedantic, clippy::nursery)]
|
||||
|
||||
pub mod factory;
|
||||
pub mod pool;
|
||||
3554
substreams/ethereum-uniswap-v2/src/abi/pool.rs
Normal file
3554
substreams/ethereum-uniswap-v2/src/abi/pool.rs
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user