376 lines
17 KiB
Rust
376 lines
17 KiB
Rust
use substreams_ethereum::pb::eth::v2::{Call, Log};
|
|
use substreams_ethereum::{Event, Function};
|
|
|
|
use crate::abi;
|
|
use crate::pb;
|
|
use pb::tycho::evm::v1::{self as tycho};
|
|
use substreams::hex;
|
|
|
|
use substreams::scalar::BigInt;
|
|
|
|
const EMPTY_BYTES32: [u8; 32] = [0; 32];
|
|
const EMPTY_ADDRESS: [u8; 20] = hex!("0000000000000000000000000000000000000000");
|
|
|
|
const CRYPTO_SWAP_REGISTRY: [u8; 20] = hex!("897888115Ada5773E02aA29F775430BFB5F34c51");
|
|
const MAIN_REGISTRY: [u8; 20] = hex!("90E00ACe148ca3b23Ac1bC8C240C2a7Dd9c2d7f5");
|
|
const CRYPTO_POOL_FACTORY: [u8; 20] = hex!("F18056Bbd320E96A48e3Fbf8bC061322531aac99");
|
|
const META_POOL_FACTORY: [u8; 20] = hex!("B9fC157394Af804a3578134A6585C0dc9cc990d4");
|
|
|
|
/// This trait defines some helpers for serializing and deserializing `Vec<BigInt` which is needed
|
|
/// to be able to encode the `normalized_weights` and `weights` `Attribute`s. This should also be
|
|
/// handled by any downstream application.
|
|
trait SerializableVecBigInt {
|
|
fn serialize_bytes(&self) -> Vec<u8>;
|
|
fn deserialize_bytes(bytes: &[u8]) -> Vec<BigInt>;
|
|
}
|
|
|
|
impl SerializableVecBigInt for Vec<BigInt> {
|
|
fn serialize_bytes(&self) -> Vec<u8> {
|
|
self.iter()
|
|
.flat_map(|big_int| big_int.to_signed_bytes_be())
|
|
.collect()
|
|
}
|
|
fn deserialize_bytes(bytes: &[u8]) -> Vec<BigInt> {
|
|
bytes
|
|
.chunks_exact(32)
|
|
.map(|chunk| BigInt::from_signed_bytes_be(chunk))
|
|
.collect::<Vec<BigInt>>()
|
|
}
|
|
}
|
|
|
|
pub fn address_map(
|
|
call_address: &[u8; 20],
|
|
log: &Log,
|
|
call: &Call,
|
|
) -> Option<tycho::ProtocolComponent> {
|
|
match *call_address {
|
|
CRYPTO_SWAP_REGISTRY => {
|
|
let pool_added = abi::crypto_swap_registry::events::PoolAdded::match_and_decode(log)?;
|
|
|
|
let add_pool = abi::crypto_swap_registry::functions::AddPool1::match_and_decode(call)
|
|
.map(|add_pool| abi::crypto_swap_registry::functions::AddPool3 {
|
|
pool: add_pool.pool,
|
|
lp_token: add_pool.lp_token,
|
|
gauge: add_pool.gauge,
|
|
zap: add_pool.zap,
|
|
n_coins: add_pool.n_coins,
|
|
name: add_pool.name,
|
|
base_pool: EMPTY_ADDRESS.clone().into(),
|
|
has_positive_rebasing_tokens: false,
|
|
})
|
|
.or_else(|| {
|
|
abi::crypto_swap_registry::functions::AddPool2::match_and_decode(call).map(
|
|
|add_pool| abi::crypto_swap_registry::functions::AddPool3 {
|
|
pool: add_pool.pool,
|
|
lp_token: add_pool.lp_token,
|
|
gauge: add_pool.gauge,
|
|
zap: add_pool.zap,
|
|
n_coins: add_pool.n_coins,
|
|
name: add_pool.name,
|
|
base_pool: add_pool.base_pool,
|
|
has_positive_rebasing_tokens: false,
|
|
},
|
|
)
|
|
})
|
|
.or_else(|| {
|
|
abi::crypto_swap_registry::functions::AddPool3::match_and_decode(call)
|
|
})?;
|
|
|
|
// We need to perform an eth_call in order to actually get the pool's tokens
|
|
let coins_function = abi::crypto_swap_registry::functions::GetCoins {
|
|
pool: add_pool.pool,
|
|
};
|
|
|
|
let coins = coins_function.call(CRYPTO_SWAP_REGISTRY.to_vec())?;
|
|
let trimmed_coins: Vec<_> = coins
|
|
.get(0..add_pool.n_coins.to_i32() as usize)
|
|
.unwrap_or(&[])
|
|
.to_vec();
|
|
|
|
Some(tycho::ProtocolComponent {
|
|
id: hex::encode(&pool_added.pool),
|
|
tokens: trimmed_coins,
|
|
contracts: vec![call_address.into(), pool_added.pool],
|
|
static_att: vec![
|
|
tycho::Attribute {
|
|
name: "pool_type".into(),
|
|
value: "CryptoSwap".into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "name".into(),
|
|
value: add_pool.name.into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "lp_token".into(),
|
|
value: add_pool.lp_token.into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
],
|
|
|
|
change: tycho::ChangeType::Creation.into(),
|
|
})
|
|
}
|
|
MAIN_REGISTRY => {
|
|
let pool_created = abi::main_registry::events::PoolAdded::match_and_decode(log)?;
|
|
let add_pool =
|
|
abi::main_registry::functions::AddPoolWithoutUnderlying::match_and_decode(call)
|
|
.map(|add_pool| abi::main_registry::functions::AddPool {
|
|
pool: add_pool.pool,
|
|
lp_token: add_pool.lp_token,
|
|
rate_info: add_pool.rate_info,
|
|
decimals: add_pool.decimals,
|
|
n_coins: add_pool.n_coins,
|
|
underlying_decimals: BigInt::from(0), // not needed
|
|
has_initial_a: add_pool.has_initial_a,
|
|
is_v1: add_pool.is_v1,
|
|
name: add_pool.name,
|
|
})
|
|
.or_else(|| {
|
|
abi::main_registry::functions::AddMetapool1::match_and_decode(call).map(
|
|
|add_pool| abi::main_registry::functions::AddPool {
|
|
pool: add_pool.pool,
|
|
lp_token: add_pool.lp_token,
|
|
rate_info: EMPTY_BYTES32.clone(),
|
|
decimals: add_pool.decimals,
|
|
n_coins: add_pool.n_coins,
|
|
underlying_decimals: BigInt::from(0), // not needed
|
|
has_initial_a: true,
|
|
is_v1: false,
|
|
name: add_pool.name,
|
|
},
|
|
)
|
|
})
|
|
.or_else(|| {
|
|
abi::main_registry::functions::AddMetapool2::match_and_decode(call).map(
|
|
|add_pool| abi::main_registry::functions::AddPool {
|
|
pool: add_pool.pool,
|
|
lp_token: add_pool.lp_token,
|
|
rate_info: EMPTY_BYTES32.clone(),
|
|
decimals: add_pool.decimals,
|
|
n_coins: add_pool.n_coins,
|
|
underlying_decimals: BigInt::from(0), // not needed
|
|
has_initial_a: true,
|
|
is_v1: false,
|
|
name: add_pool.name,
|
|
},
|
|
)
|
|
})
|
|
.or_else(|| abi::main_registry::functions::AddPool::match_and_decode(call))?;
|
|
|
|
// We need to perform an eth_call in order to actually get the pool's tokens
|
|
let coins_function = abi::crypto_swap_registry::functions::GetCoins {
|
|
pool: add_pool.pool,
|
|
};
|
|
|
|
let coins = coins_function.call(CRYPTO_SWAP_REGISTRY.to_vec())?;
|
|
let trimmed_coins: Vec<_> = coins
|
|
.get(0..add_pool.n_coins.to_i32() as usize)
|
|
.unwrap_or(&[])
|
|
.to_vec();
|
|
|
|
Some(tycho::ProtocolComponent {
|
|
id: hex::encode(&pool_created.pool),
|
|
tokens: trimmed_coins,
|
|
contracts: vec![call_address.into(), pool_created.pool],
|
|
static_att: vec![
|
|
tycho::Attribute {
|
|
name: "pool_type".into(),
|
|
value: "MainRegistry".into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "name".into(),
|
|
value: add_pool.name.into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "lp_token".into(),
|
|
value: add_pool.lp_token.into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
],
|
|
change: tycho::ChangeType::Creation.into(),
|
|
})
|
|
}
|
|
CRYPTO_POOL_FACTORY => {
|
|
let pool_added =
|
|
abi::crypto_pool_factory::events::CryptoPoolDeployed::match_and_decode(log)?;
|
|
let deploy_call =
|
|
abi::crypto_pool_factory::functions::DeployPool::match_and_decode(call)?;
|
|
|
|
Some(tycho::ProtocolComponent {
|
|
id: hex::encode(&call.return_data),
|
|
tokens: pool_added.coins.into(),
|
|
contracts: vec![call_address.into(), call.return_data.clone()],
|
|
static_att: vec![
|
|
tycho::Attribute {
|
|
name: "pool_type".into(),
|
|
value: "CryptoPool".into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "name".into(),
|
|
value: pool_added.a.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "lp_token".into(),
|
|
value: pool_added.gamma.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "mid_fee".into(),
|
|
value: deploy_call.mid_fee.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "out_fee".into(),
|
|
value: deploy_call.out_fee.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "allowed_extra_profit".into(),
|
|
value: deploy_call.allowed_extra_profit.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "fee_gamma".into(),
|
|
value: deploy_call.fee_gamma.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "adjustment_step".into(),
|
|
value: deploy_call.adjustment_step.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "admin_fee".into(),
|
|
value: deploy_call.admin_fee.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "ma_half_time".into(),
|
|
value: deploy_call.ma_half_time.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "initial_price".into(),
|
|
value: deploy_call.initial_price.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
],
|
|
change: tycho::ChangeType::Creation.into(),
|
|
})
|
|
}
|
|
META_POOL_FACTORY => {
|
|
if let Some(pool_added) =
|
|
abi::meta_pool_factory::events::PlainPoolDeployed::match_and_decode(log)
|
|
{
|
|
let add_pool =
|
|
abi::meta_pool_factory::functions::DeployPlainPool1::match_and_decode(call)
|
|
.map(
|
|
|add_pool| abi::meta_pool_factory::functions::DeployPlainPool3 {
|
|
name: add_pool.name,
|
|
symbol: add_pool.symbol,
|
|
coins: add_pool.coins,
|
|
a: add_pool.a,
|
|
fee: add_pool.fee,
|
|
asset_type: BigInt::from(0),
|
|
implementation_idx: BigInt::from(0),
|
|
},
|
|
)
|
|
.or_else(|| {
|
|
abi::meta_pool_factory::functions::DeployPlainPool2::match_and_decode(
|
|
call,
|
|
)
|
|
.map(|add_pool| {
|
|
abi::meta_pool_factory::functions::DeployPlainPool3 {
|
|
name: add_pool.name,
|
|
symbol: add_pool.symbol,
|
|
coins: add_pool.coins,
|
|
a: add_pool.a,
|
|
fee: add_pool.fee,
|
|
asset_type: add_pool.asset_type,
|
|
implementation_idx: BigInt::from(0),
|
|
}
|
|
})
|
|
})
|
|
.or_else(|| {
|
|
abi::meta_pool_factory::functions::DeployPlainPool3::match_and_decode(
|
|
call,
|
|
)
|
|
})?;
|
|
Some(tycho::ProtocolComponent {
|
|
id: hex::encode(&call.return_data),
|
|
tokens: pool_added.coins.into(),
|
|
contracts: vec![call_address.into(), call.return_data.clone()],
|
|
static_att: vec![
|
|
tycho::Attribute {
|
|
name: "pool_type".into(),
|
|
value: "PlainPool".into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "name".into(),
|
|
value: add_pool.name.into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "fee".into(),
|
|
value: add_pool.fee.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
tycho::Attribute {
|
|
name: "a".into(),
|
|
value: add_pool.a.to_string().into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
},
|
|
],
|
|
change: tycho::ChangeType::Creation.into(),
|
|
})
|
|
} else if let Some(pool_added) =
|
|
abi::meta_pool_factory::events::MetaPoolDeployed::match_and_decode(log)
|
|
{
|
|
let add_pool =
|
|
abi::meta_pool_factory::functions::DeployMetapool1::match_and_decode(call)
|
|
.map(
|
|
|add_pool| abi::meta_pool_factory::functions::DeployMetapool2 {
|
|
base_pool: add_pool.base_pool,
|
|
name: add_pool.name,
|
|
symbol: add_pool.symbol,
|
|
coin: add_pool.coin,
|
|
a: add_pool.a,
|
|
fee: add_pool.fee,
|
|
implementation_idx: BigInt::from(0),
|
|
},
|
|
)
|
|
.or_else(|| {
|
|
abi::meta_pool_factory::functions::DeployMetapool2::match_and_decode(
|
|
call,
|
|
)
|
|
})?;
|
|
Some(tycho::ProtocolComponent {
|
|
id: hex::encode(&call.return_data),
|
|
tokens: vec![pool_added.coin, add_pool.base_pool.clone()],
|
|
contracts: vec![
|
|
call_address.into(),
|
|
call.return_data.clone(),
|
|
add_pool.base_pool.clone(),
|
|
],
|
|
static_att: vec![tycho::Attribute {
|
|
name: "pool_type".into(),
|
|
value: "MetaPool".into(),
|
|
change: tycho::ChangeType::Creation.into(),
|
|
}],
|
|
change: tycho::ChangeType::Creation.into(),
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|