Idea for contract state indexing using code generation

[chlenc]

Hello guys, I got an idea for you.
It would be cool to implement the following feature in the indexer, it would be a gamechanger

For example, creating a new indexer would look like this

forc index new swaylend-indexer --namespace composabilitylabs --contract <CONTRACT_ADDRESS_HERE> --abi <ABI_PATH_HERE>

and the indexer would take the address of the contract and abi and create an indexer instance according to them, it would also take the contract deploy block and put it automatically into the manifest.

In addition, it could take the contract storage and the corresponding events (if they exist) and automatically generate graphql types and event handlers for it.

manifest example

namespace: composabilitylabs
identifier: swaylend_indexer
abi: "./market-abi.json" # we can get this from --abi 
fuel_client: ~
graphql_schema: schema/swaylend_indexer.schema.graphql
module:
  wasm: target/wasm32-unknown-unknown/release/swaylend_indexer.wasm
metrics: ~
contract_id: fuel1j72ejmlu5d2qsxwmazkwwfk54ql9gydly9mm5lzv5lsmt2xlr9eqn59m8x # we can get this from --contract 
start_block: 2439688 # not sure how but should be possible to get deploy block of the contract
end_block: ~
resumable: true

contract events

pub struct CollateralConfigurationsEvent{configuration: CollateralConfiguration}

pub struct UserBasicEvent{user_basic: UserBasic, address: Address}

pub struct UserCollateralEvent{
    address: Address,
    asset_id: AssetId,
    amount: u64,
}

contract storage

storage {
    collateral_configurations: StorageMap<AssetId, CollateralConfiguration> = StorageMap {}, 
    collateral_configurations_keys: StorageVec<AssetId> = StorageVec {},
    pause_config: PauseConfiguration = PauseConfiguration::default(),
    totals_collateral: StorageMap<AssetId, u64> = StorageMap {},
    user_collateral: StorageMap<(Address, AssetId), u64> = StorageMap {},
    user_basic: StorageMap<Address, UserBasic> = StorageMap {},
    market_basic: MarketBasics = MarketBasics::default(),
    
    debug_timestamp: u64 = 0,
}

and looks like based on events and storage we can autogenerate this code

type CollateralConfigurationEntity @entity {
    id: ID! 
    asset_id: AssetId!
    price_feed: ContractId!
    decimals: UInt8!
    borrow_collateral_factor: UInt8!
    liquidate_collateral_factor: UInt8!
    liquidation_penalty: UInt8!
    supply_cap: UInt8!
    paused: Boolean!
}

type UserBasicEntity @entity {
    id: ID! 
    address: Address!
    principal_absolute: UInt8!
    principal_negative: Boolean!
    base_tracking_index: UInt8!
    base_tracking_accrued: UInt8!
    reward_claimed: UInt8!
}

type UserCollateralEntity @entity {
    id: ID! 
    address: Address!
    asset_id: AssetId!
    amount: UInt8!
}

and also this code

fn handle_asset_collateral_event(event: AssetCollateralEvent) {
        let entry = CollateralConfigurationEntity {
            id: uid(&event.configuration.asset_id.0),
            asset_id: event.configuration.asset_id.0.into(),
            price_feed: event.configuration.price_feed,
            decimals: event.configuration.decimals,
            borrow_collateral_factor: event.configuration.borrow_collateral_factor,
            liquidate_collateral_factor: event.configuration.liquidate_collateral_factor,
            liquidation_penalty: event.configuration.liquidation_penalty,
            supply_cap: event.configuration.supply_cap,
            paused: event.configuration.paused,
        };
        entry.save();

    }

    fn handle_user_basic_event(event: UserBasicEvent) {
        let entry = UserBasicEntity {
            id: uid(&event.address),
            address: event.address,
            principal_absolute: event.user_basic.principal.value,
            principal_negative: event.user_basic.principal.negative,
            base_tracking_index: event.user_basic.base_tracking_index,
            base_tracking_accrued: event.user_basic.base_tracking_accrued,
            reward_claimed: event.user_basic.reward_claimed,
        };
        entry.save();

    }

    fn handle_user_collateral_event(event: UserCollateralEvent) {
        let entry = UserCollateralEntity {
            id: uid([event.address.into(), event.asset_id.0].concat()),
            address: event.address,
            asset_id: event.asset_id.0.into(),
            amount: event.amount,
        };
        entry.save();

    }

[ra0x3]

Thanks @chlenc we've got @lostman working on this over in #846