Implement fossil index update proof system

contracts/l2/fossil.cairo

@@ -0,0 +1,106 @@
+%lang starknet
+
+from starkware.cairo.common.cairo_builtins import HashBuiltin, BitwiseBuiltin
+from starkware.cairo.common.uint256 import (
+    Uint256,
+    uint256_and,
+    uint256_le,
+    uint256_unsigned_div_rem,
+)
+
+from contracts.l2.tokens.incentivized_erc20 import last_update
+
+struct StorageSlot:
+    member word_1 : felt
+    member word_2 : felt
+    member word_3 : felt
+    member word_4 : felt
+end
+
+@contract_interface
+namespace IFossil:
+    func get_storage_uint(
+        block : felt,
+        account_160 : felt,
+        slot : StorageSlot,
+        proof_sizes_bytes_len : felt,
+        proof_sizes_bytes : felt*,
+        proof_sizes_words_len : felt,
+        proof_sizes_words : felt*,
+        proofs_concat_len : felt,
+        proofs_concat : felt*,
+    ) -> (res : Uint256):
+    end
+end
+
+@storage_var
+func fossil() -> (address : felt):
+end
+
+@storage_var
+func asset_data_slot() -> (slot : StorageSlot):
+end
+
+@storage_var
+func incentives_controller() -> (controller : felt):
+end
+
+func get_asset_data{
+    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr, bitwise_ptr : BitwiseBuiltin*
+}(
+    block : Uint256,
+    proof_sizes_bytes_len : felt,
+    proof_sizes_bytes : felt*,
+    proof_sizes_words_len : felt,
+    proof_sizes_words : felt*,
+    proofs_concat_len : felt,
+    proofs_concat : felt*,
+) -> (index : Uint256):
+    alloc_locals
+
+    # check the proof is for the right slot
+    let (slot) = asset_data_slot.read()
+    let (account_160) = incentives_controller.read()
+    let (fossil_) = fossil.read()
+
+    # check the proof is for a later block
+    let (last_update_) = last_update.read()
+    let (le) = uint256_le(last_update_, block)
+    with_attr error_message("Rejecting old block"):
+        assert le = 1
+    end
+
+    let (asset_data : Uint256) = IFossil.get_storage_uint(
+        fossil_,
+        block.low,
+        account_160,
+        slot,
+        proof_sizes_bytes_len,
+        proof_sizes_bytes,
+        proof_sizes_words_len,
+        proof_sizes_words,
+        proofs_concat_len,
+        proofs_concat,
+    )
+
+    # let mask_emission_per_second   = Uint256(low=0x00000000000000000000000000000000, high=0xffffffffffffffffffffffffff000000)
+    # let emission_per_second_rs     = Uint256(low=0x00000000000000000000000000000000, high=0x00000000000000000000000001000000)
+    let mask_index = Uint256(
+        low=0xffffffffffffffffffff000000000000, high=0x00000000000000000000000000ffffff
+    )
+    let index_rs = Uint256(
+        low=0x00000000000000000001000000000000, high=0x00000000000000000000000000000000
+    )
+    # let mask_last_update_timestamp = Uint256(low=0x00000000000000000000ffffffffff00, high=0x00000000000000000000000000000000)
+    # let last_update_timestamp_rs   = Uint256(low=0x00000000000000000000000000000100, high=0x00000000000000000000000000000000)
+
+    # let (masked_emission_per_second) = uint256_and(asset_data, mask_emission_per_second)
+    let (masked_index) = uint256_and(asset_data, mask_index)
+    # let (masked_last_update_timestamp) = uint256_and(asset_data, mask_last_update_timestamp)
+
+    # let (emission_per_second)   = uint256_unsigned_div_rem(masked_emission_per_second, emission_per_second_rs)
+    let (index, _) = uint256_unsigned_div_rem(masked_index, index_rs)
+    # let (last_update_timestamp) = uint256_unsigned_div_rem(masked_last_update_timestamp, last_update_timestamp_rs)
+
+    return (index)
+end

contracts/l2/interfaces/Istatic_a_token.cairo

@@ -2,6 +2,7 @@
 
 from starkware.cairo.common.uint256 import Uint256
 from contracts.l2.lib.wad_ray_math import Ray
+from contracts.l2.fossil import StorageSlot
 
 @contract_interface
 namespace Istatic_a_token:
@@ -65,4 +66,25 @@ namespace Istatic_a_token:
 
     func get_rewards_index() -> (rewards_index : Ray):
     end
+
+    func get_fossil() -> (fossil : felt):
+    end
+
+    func get_slot() -> (slot : StorageSlot):
+    end
+
+    func get_incentives_controller() -> (controller : felt):
+    end
+
+    func set_l2_bridge(l2_bridge : felt):
+    end
+
+    func set_slot(slot : StorageSlot):
+    end
+
+    func set_fossil(fossil_ : felt):
+    end
+
+    func set_incentives_controller(controller : felt):
+    end
 end

contracts/l2/tokens/static_a_token.cairo

@@ -1,6 +1,6 @@
 %lang starknet
 
-from starkware.cairo.common.cairo_builtins import HashBuiltin
+from starkware.cairo.common.cairo_builtins import HashBuiltin, BitwiseBuiltin
 from starkware.starknet.common.syscalls import get_caller_address
 from starkware.cairo.common.uint256 import Uint256
 from starkware.cairo.common.bool import TRUE
@@ -38,12 +38,24 @@ from contracts.l2.tokens.incentivized_erc20 import (
 )
 from contracts.l2.lib.wad_ray_math import Ray
 
+from contracts.l2.fossil import (
+    get_asset_data,
+    fossil,
+    asset_data_slot,
+    StorageSlot,
+    incentives_controller,
+)
+
 @contract_interface
 namespace IBridge:
     func mint_rewards(recipient : felt, amount : Uint256):
     end
 end
 
+#
+# Setters
+#
+
 @external
 func set_l2_bridge{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
     l2_bridge : felt
@@ -53,6 +65,31 @@ func set_l2_bridge{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check
     return ()
 end
 
+@external
+func set_slot{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
+    slot : StorageSlot
+):
+    Ownable_only_owner()
+    asset_data_slot.write(slot)
+    return ()
+end
+
+@external
+func set_fossil{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(fossil_ : felt):
+    Ownable_only_owner()
+    fossil.write(fossil_)
+    return ()
+end
+
+@external
+func set_incentives_controller{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
+    controller : felt
+):
+    Ownable_only_owner()
+    incentives_controller.write(controller)
+    return ()
+end
+
 #
 # Getters
 #
@@ -64,6 +101,26 @@ func get_last_update{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_che
     return incentivized_erc20_get_last_update()
 end
 
+@view
+func get_fossil{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
+    fossil : felt
+):
+    return fossil.read()
+end
+
+@view
+func get_slot{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
+    slot : StorageSlot
+):
+    return asset_data_slot.read()
+end
+
+@view
+func get_incentives_controller{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
+    ) -> (controller : felt):
+    return incentives_controller.read()
+end
+
 @view
 func name{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (name : felt):
     return ERC20_name()
@@ -102,6 +159,15 @@ func allowance{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
     return ERC20_allowance(owner, spender)
 end
 
+@view
+func get_user_claimable_rewards{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
+    user : felt
+) -> (user_claimable_rewards : Uint256):
+    alloc_locals
+    let (res) = incentivized_erc20_get_claimable_rewards(user)
+    return (res.wad)
+end
+
 #
 # Externals
 #
@@ -216,6 +282,33 @@ func push_rewards_index{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_
     return ()
 end
 
+@external
+func prove_rewards_index{
+    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr, bitwise_ptr : BitwiseBuiltin*
+}(
+    block : Uint256,
+    proof_sizes_bytes_len : felt,
+    proof_sizes_bytes : felt*,
+    proof_sizes_words_len : felt,
+    proof_sizes_words : felt*,
+    proofs_concat_len : felt,
+    proofs_concat : felt*,
+) -> ():
+    alloc_locals
+    let (index) = get_asset_data(
+        block,
+        proof_sizes_bytes_len,
+        proof_sizes_bytes,
+        proof_sizes_words_len,
+        proof_sizes_words,
+        proofs_concat_len,
+        proofs_concat,
+    )
+
+    incentivized_erc20_push_rewards_index(block, Ray(index))
+    return ()
+end
+
 @external
 func get_rewards_index{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (
     rewards_index : Ray
@@ -231,12 +324,3 @@ func get_user_rewards_index{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, ra
     let (res) = incentivized_erc20_get_user_rewards_index(user)
     return (res.ray)
 end
-
-@view
-func get_user_claimable_rewards{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
-    user : felt
-) -> (user_claimable_rewards : Uint256):
-    alloc_locals
-    let (res) = incentivized_erc20_get_claimable_rewards(user)
-    return (res.wad)
-end