Mini Storage Proofs

   // =================================
    // Step 1. Accessing the block hash
    // =================================

    // get origin chain's block hash on destination chain
    function getBlockHash(uint256 blockNumber) public view returns (bytes32) {
        // Ensure the block number is within the last 256 blocks
        require(blockNumber < block.number, "Block number is too high");
        require(
            blockNumber >= block.number - 256,
            "Block number is too old, use accumulator"
        );

        // Syscall to get block hash
        return blockhash(blockNumber);
    }

pub async fn get_encoded_block_header() -> Result<()> {
    let block = client.get_block(BlockNumber::Latest).await?.unwrap();
    ...
}

   // =================================
    // 2. Accessing the block header
    // =================================

    // verify origin chain's block header on destination chain
    function getBlockHeader(
        uint256 blockNumber,
        bytes memory blockHeader
    ) public view returns (bool) {
        // Step 1. Retrieve the block hash
        bytes32 retrievedBlockHash = getBlockHash(blockNumber);

        // Step 2. Hash the provided block header and compare
        bytes32 providedBlockHeaderHash = keccak256(blockHeader);

        // Step 3. Verify it
        if (providedBlockHeaderHash == retrievedBlockHash) {
            return true;
        } else {
            return false;
        }
    }

    // =================================
    // 3. Determining the Desired Root
    // =================================

    // get origin chain's state root on destination chain
    function getStateRoot(
        uint256 blockNumber,
        bytes memory blockHeader
    ) public view returns (bytes32) {
        bool is_valid_header = getBlockHeader(blockNumber, blockHeader);
        require(is_valid_header, "Invalid block header");

        Lib_RLPReader.RLPItem[] memory items = blockHeader
            .toRLPItem()
            .readList();
        return bytes32(items[3].readUint256()); // The state root is the 4th item in a block header
    }

    // get origin chain's receipt root on destination chain
    function getReceiptsRoot(
        uint256 blockNumber,
        bytes memory blockHeader
    ) public view returns (bytes32) {
        bool is_valid_header = getBlockHeader(blockNumber, blockHeader);
        require(is_valid_header, "Invalid block header");

        Lib_RLPReader.RLPItem[] memory items = blockHeader
            .toRLPItem()
            .readList();
        return bytes32(items[5].readUint256()); // The receipts root is the 6th item
    }

    // get origin chain's transaction root on destination chain
    function getTransactionRoot(
        uint256 blockNumber,
        bytes memory blockHeader
    ) public view returns (bytes32) {
        bool is_valid_header = getBlockHeader(blockNumber, blockHeader);
        require(is_valid_header, "Invalid block header");

        Lib_RLPReader.RLPItem[] memory items = blockHeader
            .toRLPItem()
            .readList();
        return bytes32(items[4].readUint256()); // The transactions root is the 5th item
    }

let proof_response = client
        .get_proof(
            "0x3073F6Cd5799d754Ea93FcF54c53afd802477983",
            vec![H256::zero()],
            Some(BlockId::Number(BlockNumber::Latest)),
        )
        .await?;

    // =================================
    // 4. Verifying Data Against the Chosen Root (Account)
    // =================================

    function verifyAccount(
        uint256 blockNumber,
        bytes memory blockHeader,
        bytes memory accountTrieProof,
        address account
    )
        public
        view
        returns (
            uint256 nonce,
            uint256 accountBalance,
            bytes32 codeHash,
            bytes32 storageRoot
        )
    {
        // Retrieve the root based on the specified type (valid)
        bytes32 stateRoot = getStateRoot(blockNumber, blockHeader);

        // Retrieve the key from the account
        bytes memory accountKey = abi.encodePacked(account);

        // Verify the account
        (bool doesAccountExist, bytes memory accountRLP) = Lib_SecureMerkleTrie
            .get(accountKey, accountTrieProof, stateRoot);

        // Decode the [`accountRLP`] into a struct
        (nonce, accountBalance, storageRoot, codeHash) = _decodeAccountFields(
            doesAccountExist,
            accountRLP
        );
    }

    // =================================
    // 5. Verifying Data Against the Chosen Root (Storage)
    // =================================
    function verifyStorage(
        bytes32 storageRoot,
        bytes32 slot,
        bytes calldata storageSlotTrieProof
    ) public view returns (bytes32 slotValue) {
        // Get valid storage root from account ( Step 4 )

        // Retrieve the key from the storage slot
        bytes memory storageKey = abi.encodePacked(slot);

        // Verify the account
        (, bytes memory slotValueRLP) = Lib_SecureMerkleTrie.get(
            storageKey,
            storageSlotTrieProof,
            storageRoot
        );

        // Decode the [`slotValueRLP`] into a value
        slotValue = slotValueRLP.toRLPItem().readBytes32();
    }

        // =================================
        // Step 1. Accessing the block hash
        // =================================

        // get origin chain's block hash on destination chain
        fn get_block_hash(self: @ContractState, block_number: u64) -> felt252 {
            let latest_block_number: u64 = get_block_info().unbox().block_number;
             // Ensure the block number is within the last 256 blocks
            assert(block_number >= latest_block_number - 256, 'Block number is too old');
            assert(block_number < latest_block_number, 'Block number is too high');

            // Syscall to get block hash
            get_block_hash_syscall(block_number).unwrap()
        }

        // =================================
        // 2. Accessing the block header
        // =================================

        // verify origin chain's block header on destination chain
        fn get_block_header(
            self: @ContractState,
            block_number: felt252,
            global_state_root: felt252,
            sequencer_address: felt252,
            block_timestamp: felt252,
            transaction_count: felt252,
            transaction_commitment: felt252,
            event_count: felt252,
            event_commitment: felt252,
            parent_block_hash: felt252
        ) -> bool {
            // Step 1. Retrieve the block hash
            let block_number_u64: u64 = block_number.try_into().unwrap();
            let retrieved_block_hash = get_block_hash_syscall(block_number_u64).unwrap();

            let hash_pedersen = PedersenImpl::new(0);
            hash_pedersen.update(block_number);
            hash_pedersen.update(global_state_root);
            hash_pedersen.update(sequencer_address);
            hash_pedersen.update(block_timestamp);
            hash_pedersen.update(transaction_count);
            hash_pedersen.update(transaction_commitment);
            hash_pedersen.update(event_count);
            hash_pedersen.update(event_commitment);
            hash_pedersen.update(0);
            hash_pedersen.update(0);
            hash_pedersen.update(parent_block_hash);
            // Step 2. Hash the provided block header and compare
            let provided_block_header_hash = hash_pedersen.finalize();

            // Step 3. Verify it
            if provided_block_header_hash == retrieved_block_hash {
                return true;
            } else {
                return false;
            }
        }

       // =================================
        // 3. Determining the Desired Root (Contract tree root)
        // =================================

        // get origin chain's contract_trie_root on destination chain
        fn get_contract_trie_root(
            self: @ContractState,
            block_number: felt252,
            global_state_root: felt252,
            contract_trie_root: felt252,
            class_trie_root: felt252
        ) -> felt252 {
            // Step 1. Construct the state commitment
            let hash_poseidon = PoseidonImpl::new();
            hash_poseidon.update('STARKNET_STATE_V0');
            hash_poseidon.update(contract_trie_root);
            hash_poseidon.update(class_trie_root);
            let state_commitment = hash_poseidon.finalize();

            // Step 2. Verify the state commitment
            assert(state_commitment == global_state_root, 'state commitment does not match');

            return contract_trie_root;
        }

        // =================================
        // 4. Verifying Data Against the Chosen Root (Contract)
        // =================================

        fn verify_contract(
            self: @ContractState,
            block_number: felt252,
            contract_trie_root: felt252,
            contract_trie_proof: Span<felt252>,
            class_hash: felt252,
            storage_root: felt252,
            nonce: felt252,
            contract_state_hash_version: felt252,
        ) -> (felt252, felt252, felt252, felt252) {
            // Step 1. Compute the leaf of contract trie
            let hash_pedersen = PedersenImpl::new(0);
            hash_pedersen.update(class_hash);
            hash_pedersen.update(storage_root);
            hash_pedersen.update(nonce);
            hash_pedersen.update(contract_state_hash_version);
            let contract_leaf = hash_pedersen.finalize();

            // Step 2. Verify the root
            let mut merkle_tree: MerkleTree<Hasher> = MerkleTreeTrait::new();
            let computed_root = merkle_tree.compute_root(contract_leaf, contract_trie_proof);
            assert(computed_root == contract_trie_root, 'compute valid root failed');

            // Step 3. Verify the proof
            let result = merkle_tree.verify(computed_root, contract_leaf, contract_trie_proof);
            assert(result, 'verify valid proof failed');

            return (class_hash, storage_root, nonce, contract_state_hash_version);
        }

        // =================================
        // 5. Verifying Data Against the Chosen Root (Storage)
        // =================================
        fn verify_storage(
            self: @ContractState,
            state_commitment: felt252,
            class_commitment: felt252,
            contract_address: felt252,
            storage_address: felt252,
            storage_trie_proof: Span<felt252>,
            contract_trie_proof: Span<felt252>,
            class_hash: felt252,
            storage_root: felt252,
            nonce: felt252,
            contract_state_hash_version: felt252,
        ) -> felt252 {
            // Step 1. Construct StateProof
            let storage_proof = ContractStateProof {
                class_commitment,
                contract_data: ContractData {
                    class_hash,
                    nonce,
                    contract_state_hash_version,
                    storage_proof: cast_proof_type(storage_trie_proof),
                },
                contract_proof: cast_proof_type(contract_trie_proof),
            };

             // Step 2. Verify the proof and retreive value
            let storage_value = verify(
                state_commitment, contract_address, storage_address, storage_proof
            );
            return storage_value;
        }
    }