4991 lines
202 KiB
Rust
4991 lines
202 KiB
Rust
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt> for A {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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::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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for AdminActionsDeadline {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 {
|
|
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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for AdminBalances {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for AdminFee {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 {
|
|
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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for Balances {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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::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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for CalcTokenAmount {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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),
|
|
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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for CalcWithdrawOneCoin {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 {
|
|
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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for Coins {
|
|
fn output(data: &[u8]) -> Result<Vec<u8>, 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<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),
|
|
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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct CommitTransferOwnership {
|
|
pub owner: Vec<u8>,
|
|
}
|
|
impl CommitTransferOwnership {
|
|
const METHOD_ID: [u8; 4] = [107u8, 68u8, 26u8, 64u8];
|
|
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 {
|
|
owner: 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.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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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::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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt> for Fee {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for FutureA {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for FutureATime {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for FutureAdminFee {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for FutureFee {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for FutureOwner {
|
|
fn output(data: &[u8]) -> Result<Vec<u8>, 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<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::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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for GetDy {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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::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<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for GetDyUnderlying {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for GetVirtualPrice {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for InitialA {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for InitialATime {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<Vec<u8>> for Owner {
|
|
fn output(data: &[u8]) -> Result<Vec<u8>, 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<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),
|
|
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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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),
|
|
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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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::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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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),
|
|
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<u8> {
|
|
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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
self.encode()
|
|
}
|
|
}
|
|
impl substreams_ethereum::rpc::RPCDecodable<substreams::scalar::BigInt>
|
|
for TransferOwnershipDeadline {
|
|
fn output(data: &[u8]) -> Result<substreams::scalar::BigInt, String> {
|
|
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<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 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, String> {
|
|
Self::decode(call)
|
|
}
|
|
fn encode(&self) -> Vec<u8> {
|
|
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<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 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, 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 AddLiquidity {
|
|
pub provider: Vec<u8>,
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct CommitNewAdmin {
|
|
pub deadline: substreams::scalar::BigInt,
|
|
pub admin: Vec<u8>,
|
|
}
|
|
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<Self, String> {
|
|
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, String> {
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct NewAdmin {
|
|
pub admin: Vec<u8>,
|
|
}
|
|
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<Self, String> {
|
|
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, String> {
|
|
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<Self, String> {
|
|
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, String> {
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct RemoveLiquidity {
|
|
pub provider: Vec<u8>,
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct RemoveLiquidityImbalance {
|
|
pub provider: Vec<u8>,
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct RemoveLiquidityOne {
|
|
pub provider: Vec<u8>,
|
|
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<Self, String> {
|
|
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, String> {
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub struct TokenExchange {
|
|
pub buyer: Vec<u8>,
|
|
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<Self, String> {
|
|
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, String> {
|
|
Self::decode(log)
|
|
}
|
|
}
|
|
} |