scrvUSD oracle

contracts/oracles/OptimismBlockHashOracle.vy

@@ -0,0 +1,81 @@
+# pragma version 0.4.0
+"""
+@title Optimism Block Hash oracle
+@notice A contract that saves L1 block hashes.
+@license MIT
+@author curve.fi
+@custom:version 0.0.1
+@custom:security security@curve.fi
+"""
+
+version: public(constant(String[8])) = "0.0.1"
+
+interface IL1Block:
+    def number() -> uint64: view
+    def hash() -> bytes32: view
+
+
+event CommitBlockHash:
+    committer: indexed(address)
+    number: indexed(uint256)
+    hash: bytes32
+
+event ApplyBlockHash:
+    number: indexed(uint256)
+    hash: bytes32
+
+L1_BLOCK: constant(IL1Block) = IL1Block(0x4200000000000000000000000000000000000015)
+
+block_hash: public(HashMap[uint256, bytes32])
+commitments: public(HashMap[address, HashMap[uint256, bytes32]])
+
+
+@view
+@external
+def get_block_hash(_number: uint256) -> bytes32:
+    """
+    @notice Query the block hash of a block.
+    @dev Reverts for block numbers which have yet to be set.
+    """
+    block_hash: bytes32 = self.block_hash[_number]
+    assert block_hash != empty(bytes32)
+
+    return block_hash
+
+
+@internal
+def _update_block_hash() -> (uint256, bytes32):
+    number: uint256 = convert(staticcall L1_BLOCK.number(), uint256)
+    hash: bytes32 = staticcall L1_BLOCK.hash()
+    self.block_hash[number] = hash
+
+    return number, hash
+
+
+@external
+def commit() -> uint256:
+    """
+    @notice Commit (and apply) a block hash.
+    @dev Same as `apply()` but saves committer
+    """
+    number: uint256 = 0
+    hash: bytes32 = empty(bytes32)
+    number, hash = self._update_block_hash()
+
+    self.commitments[msg.sender][number] = hash
+    log CommitBlockHash(msg.sender, number, hash)
+    log ApplyBlockHash(number, hash)
+    return number
+
+
+@external
+def apply() -> uint256:
+    """
+    @notice Apply a block hash.
+    """
+    number: uint256 = 0
+    hash: bytes32 = empty(bytes32)
+    number, hash = self._update_block_hash()
+
+    log ApplyBlockHash(number, hash)
+    return number

contracts/oracles/ScrvusdOracle.vy

@@ -0,0 +1,219 @@
+# pragma version 0.4.0
+"""
+@title scrvUSD oracle
+@notice Oracle of scrvUSD share price for StableSwap pool and other integrations.
+    Price updates are linearly smoothed with max acceleration to eliminate sharp changes.
+@license MIT
+@author curve.fi
+@custom:version 0.0.1
+@custom:security security@curve.fi
+"""
+
+version: public(constant(String[8])) = "0.0.1"
+
+from snekmate.auth import ownable
+
+initializes: ownable
+exports: ownable.__interface__
+
+event PriceUpdate:
+    new_price: uint256  # price to achieve
+    at: uint256  # timestamp at which price will be achieved
+
+event SetProver:
+    prover: address
+
+struct Interval:
+    previous: uint256
+    future: uint256
+
+
+# scrvUSD Vault rate replication
+# 0 total_debt
+# 1 total_idle
+ASSETS_PARAM_CNT: constant(uint256) = 2
+# 0 totalSupply
+# 1 full_profit_unlock_date
+# 2 profit_unlocking_rate
+# 3 last_profit_update
+# 4 balance_of_self
+SUPPLY_PARAM_CNT: constant(uint256) = 5
+MAX_BPS_EXTENDED: constant(uint256) = 1_000_000_000_000
+
+prover: public(address)
+
+price: public(Interval)  # price of asset per share
+time: public(Interval)
+
+max_acceleration: public(uint256)  # precision 10**18
+
+
+@deploy
+def __init__(_initial_price: uint256, _max_acceleration: uint256):
+    """
+    @param _initial_price Initial price of asset per share (10**18)
+    @param _max_acceleration Maximum acceleration (10**12)
+    """
+    self.price = Interval(previous=_initial_price, future=_initial_price)
+    self.time = Interval(previous=block.timestamp, future=block.timestamp)
+
+    self.max_acceleration = _max_acceleration
+
+    ownable.__init__()
+
+
+@view
+@internal
+def _price_per_share(ts: uint256) -> uint256:
+    """
+    @notice Using linear interpolation assuming updates are often enough
+        for absolute difference \approx relative difference
+    """
+    price: Interval = self.price
+    time: Interval = self.time
+    if ts >= time.future:
+        return price.future
+    if ts <= time.previous:
+        return price.previous
+    return (price.previous * (time.future - ts) + price.future * (ts - time.previous)) // (time.future - time.previous)
+
+
+@view
+@external
+def pricePerShare(ts: uint256=block.timestamp) -> uint256:
+    """
+    @notice Get the price per share (pps) of the vault.
+    @dev NOT precise. Price is smoothed over time to eliminate sharp changes.
+    @param ts Timestamp to look price at. Only near future is supported.
+    @return The price per share.
+    """
+    return self._price_per_share(ts)
+
+
+@view
+@external
+def pricePerAsset(ts: uint256=block.timestamp) -> uint256:
+    """
+    @notice Get the price per asset of the vault.
+    @dev NOT precise. Price is smoothed over time to eliminate sharp changes.
+    @param ts Timestamp to look price at. Only near future is supported.
+    @return The price per share.
+    """
+    return 10 ** 36 // self._price_per_share(ts)
+
+
+@view
+@external
+def price_oracle(i: uint256=0) -> uint256:
+    """
+    @notice Alias of `pricePerShare` and `pricePerAsset` made for compatability
+    @param i 0 for scrvusd per crvusd, 1 for crvusd per scrvusd
+    @return Price with 10^18 precision
+    """
+    return self._price_per_share(block.timestamp) if i == 0 else 10 ** 36 // self._price_per_share(block.timestamp)
+
+
+@view
+def _unlocked_shares(
+    full_profit_unlock_date: uint256,
+    profit_unlocking_rate: uint256,
+    last_profit_update: uint256,
+    balance_of_self: uint256,
+    ts: uint256,
+) -> uint256:
+    """
+    Returns the amount of shares that have been unlocked.
+    To avoid sudden price_per_share spikes, profits can be processed
+    through an unlocking period. The mechanism involves shares to be
+    minted to the vault which are unlocked gradually over time. Shares
+    that have been locked are gradually unlocked over profit_max_unlock_time.
+    """
+    unlocked_shares: uint256 = 0
+    if full_profit_unlock_date > ts:
+        # If we have not fully unlocked, we need to calculate how much has been.
+        unlocked_shares = profit_unlocking_rate * (ts - last_profit_update) // MAX_BPS_EXTENDED
+
+    elif full_profit_unlock_date != 0:
+        # All shares have been unlocked
+        unlocked_shares = balance_of_self
+
+    return unlocked_shares
+
+
+@view
+def _total_supply(parameters: uint256[ALL_PARAM_CNT], ts: uint256) -> uint256:
+    # Need to account for the shares issued to the vault that have unlocked.
+    # return self.total_supply - self._unlocked_shares()
+    return parameters[ASSETS_PARAM_CNT + 0] -\
+        self._unlocked_shares(
+            parameters[ASSETS_PARAM_CNT + 1],  # full_profit_unlock_date
+            parameters[ASSETS_PARAM_CNT + 2],  # profit_unlocking_rate
+            parameters[ASSETS_PARAM_CNT + 3],  # last_profit_update
+            parameters[ASSETS_PARAM_CNT + 4],  # balance_of_self
+            ts,  # block.timestamp
+        )
+
+@view
+def _total_assets(parameters: uint256[ALL_PARAM_CNT]) -> uint256:
+    """
+    @notice Total amount of assets that are in the vault and in the strategies.
+    """
+    # return self.total_idle + self.total_debt
+    return parameters[0] + parameters[1]
+
+
+@external
+def update_price(
+    _parameters: uint256[ASSETS_PARAM_CNT + SUPPLY_PARAM_CNT],
+    _ts: uint256,
+) -> uint256:
+    """
+    @notice Update price using `_parameters`
+    @param _parameters Parameters of Yearn Vault to calculate scrvUSD price
+    @param _ts Timestamp at which these parameters are true
+    @return Relative price change of final price with 10^18 precision
+    """
+    assert msg.sender == self.prover
+
+    current_price: uint256 = self._price_per_share(block.timestamp)
+    new_price: uint256 = self._total_assets(_parameters) * 10 ** 18 //\
+        self._total_supply(_parameters, _ts)
+
+    # Price is always growing and updates are never from future,
+    # hence allow only increasing updates
+    future_price: uint256 = self.price.future
+    if new_price > future_price:
+        self.price = Interval(previous=current_price, future=new_price)
+
+        rel_price_change: uint256 = (new_price - current_price) * 10 ** 18 // current_price + 1  # 1 for rounding up
+        future_ts: uint256 = block.timestamp + rel_price_change // self.max_acceleration
+        self.time = Interval(previous=block.timestamp, future=future_ts)
+
+        log PriceUpdate(new_price, future_ts)
+        return new_price * 10 ** 18 // future_price
+    return 10 ** 18
+
+
+@external
+def set_max_acceleration(_max_acceleration: uint256):
+    """
+    @notice Set maximum acceleration of scrvUSD.
+        Must be less than StableSwap's minimum fee.
+        fee / (2 * block_time) is considered to be safe.
+    @param _max_acceleration Maximum acceleration (per sec)
+    """
+    ownable._check_owner()
+
+    assert 10 ** 8 <= _max_acceleration and _max_acceleration <= 10 ** 18
+    self.max_acceleration = _max_acceleration
+
+
+@external
+def set_prover(_prover: address):
+    """
+    @notice Set the account with prover permissions.
+    """
+    ownable._check_owner()
+
+    self.prover = _prover
+    log SetProver(_prover)

contracts/oracles/ScrvusdOracleV1.vy

@@ -0,0 +1,226 @@
+# pragma version 0.4.0
+"""
+@title scrvUSD oracle
+@notice Oracle of scrvUSD share price for StableSwap pool and other integrations.
+    Price updates are linearly smoothed with max acceleration to eliminate sharp changes.
+@license MIT
+@author curve.fi
+@custom:version 0.1.0
+@custom:security security@curve.fi
+"""
+
+version: public(constant(String[8])) = "0.1.0"
+
+from snekmate.auth import ownable
+
+initializes: ownable
+exports: ownable.__interface__
+
+event PriceUpdate:
+    new_price: uint256  # price to achieve
+    price_params_ts: uint256  # timestamp at which price is recorded
+
+event SetProver:
+    prover: address
+
+
+# scrvUSD Vault rate replication
+# 0 total_debt
+# 1 total_idle
+ASSETS_PARAM_CNT: constant(uint256) = 2
+# 0 totalSupply
+# 1 full_profit_unlock_date
+# 2 profit_unlocking_rate
+# 3 last_profit_update
+# 4 balance_of_self
+SUPPLY_PARAM_CNT: constant(uint256) = 5
+ALL_PARAM_CNT: constant(uint256) = ASSETS_PARAM_CNT + SUPPLY_PARAM_CNT
+MAX_BPS_EXTENDED: constant(uint256) = 1_000_000_000_000
+
+prover: public(address)
+
+# smoothening
+last_prices: uint256[2]
+last_update: uint256
+# scrvusd replication parameters
+price_params: uint256[ALL_PARAM_CNT]
+price_params_ts: uint256
+
+max_acceleration: public(uint256)  # precision 10**18
+
+
+@deploy
+def __init__(_initial_price: uint256, _max_acceleration: uint256):
+    """
+    @param _initial_price Initial price of asset per share (10**18)
+    @param _max_acceleration Maximum acceleration (10**12)
+    """
+    self.last_prices = [_initial_price, _initial_price]
+    self.last_update = block.timestamp
+
+    # initial raw_price is 1
+    self.price_params[0] = 1  # totalAssets = 1
+    self.price_params[2] = 1  # totalSupply = 1
+
+    self.max_acceleration = _max_acceleration
+
+    ownable.__init__()
+
+
+@view
+@external
+def price_v0(_i: uint256=0) -> uint256:
+    """
+    @notice Get lower bound of `scrvUSD.pricePerShare()`
+    @dev Price is updated in steps, need to prove every % changed
+    @param _i 0 (default) for `pricePerShare()` and 1 for `pricePerAsset()`
+    """
+    return self._price_v0() if _i == 0 else 10**36 // self._price_v0()
+
+
+@view
+@external
+def price_v1(_i: uint256=0) -> uint256:
+    """
+    @notice Get approximate `scrvUSD.pricePerShare()`
+    @dev Price is simulated as if noone interacted to change `scrvUSD.pricePerShare()`,
+        need to adjust rate when too off.
+    @param _i 0 (default) for `pricePerShare()` and 1 for `pricePerAsset()`
+    """
+    return self._price_v1() if _i == 0 else 10**36 // self._price_v1()
+
+
+@view
+@external
+def raw_price(_i: uint256=0, _ts: uint256=block.timestamp) -> uint256:
+    """
+    @notice Get approximate `scrvUSD.pricePerShare()` without smoothening
+    @param _i 0 (default) for `pricePerShare()` and 1 for `pricePerAsset()`
+    @param _ts Timestamp at which to see price (only near period is supported)
+    """
+    return self._raw_price(_ts) if _i == 0 else 10**36 // self._raw_price(_ts)
+
+
+@view
+def _smoothed_price(last_price: uint256, ts: uint256) -> uint256:
+    raw_price: uint256 = self._raw_price(ts)
+    max_change: uint256 = self.max_acceleration * (block.timestamp - self.last_update)
+    # -max_change <= (raw_price - last_price) <= max_change
+    if unsafe_sub(raw_price + max_change, last_price) > 2 * max_change:
+        return last_price + max_change if raw_price > last_price else last_price - max_change
+    return raw_price
+
+
+@view
+def _price_v0() -> uint256:
+    return self._smoothed_price(self.last_prices[0], self.price_params_ts)
+
+
+@view
+def _price_v1() -> uint256:
+    return self._smoothed_price(self.last_prices[1], block.timestamp)
+
+
+@view
+def _unlocked_shares(
+    full_profit_unlock_date: uint256,
+    profit_unlocking_rate: uint256,
+    last_profit_update: uint256,
+    balance_of_self: uint256,
+    ts: uint256,
+) -> uint256:
+    """
+    Returns the amount of shares that have been unlocked.
+    To avoid sudden price_per_share spikes, profits can be processed
+    through an unlocking period. The mechanism involves shares to be
+    minted to the vault which are unlocked gradually over time. Shares
+    that have been locked are gradually unlocked over profit_max_unlock_time.
+    """
+    unlocked_shares: uint256 = 0
+    if full_profit_unlock_date > ts:
+        # If we have not fully unlocked, we need to calculate how much has been.
+        unlocked_shares = profit_unlocking_rate * (ts - last_profit_update) // MAX_BPS_EXTENDED
+
+    elif full_profit_unlock_date != 0:
+        # All shares have been unlocked
+        unlocked_shares = balance_of_self
+
+    return unlocked_shares
+
+
+@view
+def _total_supply(parameters: uint256[ALL_PARAM_CNT], ts: uint256) -> uint256:
+    # Need to account for the shares issued to the vault that have unlocked.
+    # return self.total_supply - self._unlocked_shares()
+    return parameters[ASSETS_PARAM_CNT + 0] -\
+        self._unlocked_shares(
+            parameters[ASSETS_PARAM_CNT + 1],  # full_profit_unlock_date
+            parameters[ASSETS_PARAM_CNT + 2],  # profit_unlocking_rate
+            parameters[ASSETS_PARAM_CNT + 3],  # last_profit_update
+            parameters[ASSETS_PARAM_CNT + 4],  # balance_of_self
+            ts,  # block.timestamp
+        )
+
+@view
+def _total_assets(parameters: uint256[ALL_PARAM_CNT]) -> uint256:
+    """
+    @notice Total amount of assets that are in the vault and in the strategies.
+    """
+    # return self.total_idle + self.total_debt
+    return parameters[0] + parameters[1]
+
+
+@view
+def _raw_price(ts: uint256) -> uint256:
+    """
+    @notice Price replication from scrvUSD vault
+    """
+    parameters: uint256[ALL_PARAM_CNT] = self.price_params
+    return self._total_assets(parameters) * 10 ** 18 // self._total_supply(parameters, ts)
+
+
+@external
+def update_price(_parameters: uint256[ALL_PARAM_CNT], ts: uint256) -> uint256:
+    """
+    @notice Update price using `_parameters`
+    @param _parameters Parameters of Yearn Vault to calculate scrvUSD price
+    @param ts Timestamp at which these parameters are true
+    @return Relative price change of final price with 10^18 precision
+    """
+    assert msg.sender == self.prover
+
+    self.last_prices = [self._price_v0(), self._price_v1()]
+    current_price: uint256 = self._raw_price(self.price_params_ts)
+    self.price_params = _parameters
+    self.price_params_ts = ts
+    new_price: uint256 = self._raw_price(ts)
+    # price is non-decreasing
+    assert current_price <= new_price, "Outdated"
+
+    log PriceUpdate(new_price, ts)
+    return new_price * 10 ** 18 // current_price
+
+
+@external
+def set_max_acceleration(_max_acceleration: uint256):
+    """
+    @notice Set maximum acceleration of scrvUSD.
+        Must be less than StableSwap's minimum fee.
+        fee / (2 * block_time) is considered to be safe.
+    @param _max_acceleration Maximum acceleration (per sec)
+    """
+    ownable._check_owner()
+
+    assert 10 ** 8 <= _max_acceleration and _max_acceleration <= 10 ** 18
+    self.max_acceleration = _max_acceleration
+
+
+@external
+def set_prover(_prover: address):
+    """
+    @notice Set the account with prover permissions.
+    """
+    ownable._check_owner()
+
+    self.prover = _prover
+    log SetProver(_prover)

contracts/provers/ScrvusdProver.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.18;
+
+import {RLPReader} from "hamdiallam/Solidity-RLP@2.0.7/contracts/RLPReader.sol";
+import {StateProofVerifier as Verifier} from "../libs/StateProofVerifier.sol";
+
+interface IBlockHashOracle {
+    function get_block_hash(uint256 _number) external view returns (bytes32);
+}
+
+interface IScrvusdOracle {
+    function update_price(
+        uint256[2 + 5] memory _parameters,
+        uint256 ts
+    ) external returns (uint256);
+}
+
+/// @title Scrvusd Prover
+/// @author Curve Finance
+contract ScrvusdProver {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    address constant SCRVUSD =
+        0x0655977FEb2f289A4aB78af67BAB0d17aAb84367;
+    bytes32 constant SCRVUSD_HASH =
+        keccak256(abi.encodePacked(SCRVUSD));
+
+    address public immutable BLOCK_HASH_ORACLE;
+    address public immutable SCRVUSD_ORACLE;
+
+    uint256 constant PARAM_CNT = 2 + 5;
+    uint256 constant PROOF_CNT = 1 + PARAM_CNT;  // account proof first
+
+    constructor(address _block_hash_oracle, address _scrvusd_oracle) {
+        BLOCK_HASH_ORACLE = _block_hash_oracle;
+        SCRVUSD_ORACLE = _scrvusd_oracle;
+    }
+
+    /// Prove parameters of scrvUSD rate.
+    /// @param _block_header_rlp The block header of any block.
+    /// @param _proof_rlp The state proof of the parameters.
+    function prove(
+        bytes memory _block_header_rlp,
+        bytes memory _proof_rlp
+    ) external returns (uint256) {
+        Verifier.BlockHeader memory block_header = Verifier.parseBlockHeader(
+            _block_header_rlp
+        );
+        require(block_header.hash != bytes32(0)); // dev: invalid blockhash
+        require(
+            block_header.hash ==
+                IBlockHashOracle(BLOCK_HASH_ORACLE).get_block_hash(
+                    block_header.number
+                )
+        ); // dev: blockhash mismatch
+
+        // convert _proof_rlp into a list of `RLPItem`s
+        RLPReader.RLPItem[] memory proofs = _proof_rlp.toRlpItem().toList();
+        require(proofs.length == PROOF_CNT); // dev: invalid number of proofs
+
+        // 0th proof is the account proof for the scrvUSD contract
+        Verifier.Account memory account = Verifier.extractAccountFromProof(
+            SCRVUSD_HASH, // position of the account is the hash of its address
+            block_header.stateRootHash,
+            proofs[0].toList()
+        );
+        require(account.exists); // dev: scrvUSD account does not exist
+
+        // iterate over proofs
+        uint256[PROOF_CNT] memory PARAM_SLOTS = [
+            uint256(0), // filler, account proof, no slot
+
+            // Assets parameters
+            21, // total_debt
+            22, // total_idle
+
+            // Supply parameters
+            20, // totalSupply
+            38, // full_profit_unlock_date
+            39, // profit_unlocking_rate
+            40, // last_profit_update
+            uint256(keccak256(abi.encode(18, SCRVUSD))) // balance_of_self
+        ];
+        uint256[PARAM_CNT] memory params;
+        Verifier.SlotValue memory slot;
+        for (uint256 idx = 1; idx < PROOF_CNT; idx++) {
+            slot = Verifier.extractSlotValueFromProof(
+                keccak256(abi.encode(PARAM_SLOTS[idx])),
+                account.storageRoot,
+                proofs[idx].toList()
+            );
+            // Some slots may not be used => not exist, e.g. total_debt
+            // require(slot.exists);
+
+            params[idx - 1] = slot.value;
+        }
+        return IScrvusdOracle(SCRVUSD_ORACLE).update_price(params, block_header.timestamp);
+    }
+}

contracts/provers/ScrvusdProverTaiko.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.18;
+
+import {RLPReader} from "hamdiallam/Solidity-RLP@2.0.7/contracts/RLPReader.sol";
+import {StateProofVerifier as Verifier} from "../libs/StateProofVerifier.sol";
+
+interface ISignalService {
+    function getSyncedChainData(uint64 _chainId, bytes32 _kind, uint64 _blockId)
+        external view returns (uint64 blockId_, bytes32 chainData_);
+}
+
+interface IScrvusdOracle {
+    function update_price(
+        uint256[2 + 5] memory _parameters,
+        uint256 ts
+    ) external returns (uint256);
+}
+
+/// @title Scrvusd Prover
+/// @author Curve Finance
+contract ScrvusdProverTaiko {
+    using RLPReader for bytes;
+    using RLPReader for RLPReader.RLPItem;
+
+    address constant SCRVUSD =
+        0x0655977FEb2f289A4aB78af67BAB0d17aAb84367;
+    bytes32 constant SCRVUSD_HASH =
+        keccak256(abi.encodePacked(SCRVUSD));
+
+    address public constant SIGNAL_SERVICE = 0x1670000000000000000000000000000000000005;
+    address public immutable SCRVUSD_ORACLE;
+
+    bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");
+
+    uint256 constant PARAM_CNT = 2 + 5;
+    uint256 constant PROOF_CNT = 1 + PARAM_CNT;  // account proof first
+
+    constructor(address _scrvusd_oracle) {
+        SCRVUSD_ORACLE = _scrvusd_oracle;
+    }
+
+    /// Prove parameters of scrvUSD rate.
+    /// @param _block_number The block number of known block
+    /// @param _proof_rlp The state proof of the parameters.
+    function prove(
+        uint64 _block_number,
+        bytes memory _proof_rlp
+    ) external returns (uint256) {
+        // convert _proof_rlp into a list of `RLPItem`s
+        RLPReader.RLPItem[] memory proofs = _proof_rlp.toRlpItem().toList();
+        require(proofs.length == PROOF_CNT); // dev: invalid number of proofs
+
+        // get state root hash
+        uint64 blockId = 0;
+        bytes32 stateRoot = 0;
+        (blockId, stateRoot) = ISignalService(SIGNAL_SERVICE).getSyncedChainData(1, H_STATE_ROOT, _block_number);
+
+        // 0th proof is the account proof for the scrvUSD contract
+        Verifier.Account memory account = Verifier.extractAccountFromProof(
+            SCRVUSD_HASH, // position of the account is the hash of its address
+            stateRoot, // State root hash
+            proofs[0].toList()
+        );
+        require(account.exists); // dev: scrvUSD account does not exist
+
+        // iterate over proofs
+        uint256[PROOF_CNT] memory PARAM_SLOTS = [
+            0,  // filler (account proof)
+
+            // Assets parameters
+            uint256(21),  // total_debt
+            22,  // total_idle
+
+            // Supply parameters
+            20,  // totalSupply
+            38,  // full_profit_unlock_date
+            39,  // profit_unlocking_rate
+            40,  // last_profit_update
+            uint256(keccak256(abi.encode(18, SCRVUSD)))  // balance_of_self
+        ];
+        uint256[PARAM_CNT] memory params;
+        Verifier.SlotValue memory slot;
+        for (uint256 idx = 1; idx < PROOF_CNT; idx++) {
+            slot = Verifier.extractSlotValueFromProof(
+                keccak256(abi.encode(PARAM_SLOTS[idx])),
+                account.storageRoot,
+                proofs[idx].toList()
+            );
+            // Some slots may not be used => not exist, e.g. total_idle
+            // require(slot.exists);
+
+            params[idx - 1] = slot.value;
+        }
+        // block.timestamp not available, using `last_profit_update`
+        return IScrvusdOracle(SCRVUSD_ORACLE).update_price(params, params[5]);
+    }
+}

scripts/submit_scrvusd_price.py

@@ -0,0 +1,97 @@
+import eth_abi
+import rlp
+import web3
+from hexbytes import HexBytes
+
+BLOCK_NUMBER = 18578883
+SCRVUSD = "0x0655977FEb2f289A4aB78af67BAB0d17aAb84367"
+
+PROVER = ""
+
+ASSET_PARAM_SLOTS = [
+    21,  # total_debt
+    22,  # total_idle, slot doesn't exist
+]
+SUPPLY_PARAM_SLOTS = [
+    20,  # totalSupply
+    38,  # full_profit_unlock_date
+    39,  # profit_unlocking_rate
+    40,  # last_profit_update
+    web3.Web3.keccak(eth_abi.encode(["(uint256,address)"], [[18, SCRVUSD]])),  # balance_of_self
+    # ts from block header
+]
+
+# https://github.com/ethereum/go-ethereum/blob/master/core/types/block.go#L69
+BLOCK_HEADER = (
+    "parentHash",
+    "sha3Uncles",
+    "miner",
+    "stateRoot",
+    "transactionsRoot",
+    "receiptsRoot",
+    "logsBloom",
+    "difficulty",
+    "number",
+    "gasLimit",
+    "gasUsed",
+    "timestamp",
+    "extraData",
+    "mixHash",
+    "nonce",
+    "baseFeePerGas",  # added by EIP-1559 and is ignored in legacy headers
+    "withdrawalsRoot",  # added by EIP-4895 and is ignored in legacy headers
+    "blobGasUsed",  # added by EIP-4844 and is ignored in legacy headers
+    "excessBlobGas",  # added by EIP-4844 and is ignored in legacy headers
+    "parentBeaconBlockRoot",  # added by EIP-4788 and is ignored in legacy headers
+)
+
+
+def serialize_block(block):
+    block_header = [
+        HexBytes("0x") if (isinstance((v := block[k]), int) and v == 0) or v == "0x0" else HexBytes(block[k])
+        for k in BLOCK_HEADER
+        if k in block
+    ]
+    block_header[14] = HexBytes("0x0000000000000000")  # nonce
+    return rlp.encode(block_header)
+
+
+def serialize_proofs(proofs):
+    account_proof = list(map(rlp.decode, map(HexBytes, proofs["accountProof"])))
+    storage_proofs = [
+        list(map(rlp.decode, map(HexBytes, proof["proof"]))) for proof in proofs["storageProof"]
+    ]
+    return rlp.encode([account_proof, *storage_proofs])
+
+
+def generate_proof(eth_web3, block_number=BLOCK_NUMBER, log=False):
+    block = eth_web3.eth.get_block(block_number)
+    if log:
+        print(f"Generating proof for block {block.number}, {block.hash.hex()}")
+    block_header_rlp = serialize_block(block)
+    proof_rlp = serialize_proofs(eth_web3.eth.get_proof(SCRVUSD, ASSET_PARAM_SLOTS + SUPPLY_PARAM_SLOTS, block_number))
+
+    with open("header.txt", "w") as f:
+        f.write(block_header_rlp.hex())
+    with open("proof.txt", "w") as f:
+        f.write(proof_rlp.hex())
+
+    return block_header_rlp.hex(), proof_rlp.hex()
+
+
+def submit_proof(proofs, prover=PROVER):
+    if proofs:
+        block_header_rlp, proof_rlp = proofs
+    else:
+        with open("header.txt") as f:
+            block_header_rlp = f.read()
+        with open("proof.txt") as f:
+            proof_rlp = f.read()
+
+    if isinstance(prover, str):
+        from brownie import accounts, ScrvusdProver
+        dev = accounts.load("dev")
+        prover = ScrvusdProver.at(prover)
+        prover.prove(bytes.fromhex(block_header_rlp), bytes.fromhex(proof_rlp), {"from": dev})
+    else:
+        prover.prove(bytes.fromhex(block_header_rlp), bytes.fromhex(proof_rlp))