Add support to Pathfinder v0_8

[GMKrieger]

Issue Number: N/A

Type

• feature
• bugfix
• dev (no functional changes, no API changes)
• fmt (formatting, renaming)
• build
• docs
• testing

Description

Adds support for pathfinder v0_8. It coalesces the 2 types of request on the client and then converts the new version to the one supported by snos.

Breaking changes?

• yes
• no

[whichqua]

Left some thoughts, let me know what you think.

[whichqua]

Why do we need the String here? The enum should handle it

[whichqua]

This is related to #456 (comment)

[whichqua]

Instead of doing this, implement Display for ClientVersion

[whichqua]

Consider replacing with impl FromStr because it allows more flexibility dealing with different string types.

[whichqua]

Does this mean these tests cannot be run on v0.8?

[whichqua]

Consider a more declarative approach

Suggested change

	for node in &storage_proof.classes_proof {
	let class_proof = storage_proof
	.classes_proof
	.iter()
	.map(convert_to_trie_node)
	.collect();

[whichqua]

Consider a more declarative approach

Suggested change

	let mut contract_proof: Vec<TrieNode> = Vec::new();
	let contract_proof: Vec<TrieNode> = storage_proof.contracts_proof.nodes
	.iter()
	.map(|node| convert_to_trie_node(node))
	.collect();
	let storage_proofs: Vec<Vec<TrieNode>> = storage_proof.contracts_storage_proofs
	.iter()
	.map(|nodes| {
	nodes
	.iter()
	.map(|node| convert_to_trie_node(node))
	.collect()
	})
	.collect();

[whichqua]

This should help you avoid the if:

let contract_data = storage_proof
    .contracts_storage_proofs
    // Get the first "proof" only if it exists
    .get(0)
    // Filter out if the first proof is empty
    .filter(|proof_nodes| !proof_nodes.is_empty())
    .map(|proof_nodes| {
        let first_node = &proof_nodes[0];
        let root = first_node.node_hash;

        match &first_node.node {
            MerkleNode::Binary { left, .. } if left.to_hex_string() == "0x0" => {
                // If left is "0x0", then storage_proofs is empty
                ContractData {
                    root,
                    storage_proofs: vec![],
                }
            }
            // For all other cases (including `MerkleNode::Edge`),
            // store the computed `storage_proofs`.
            _ => ContractData { root, storage_proofs },
        }
    });

[whichqua]

Either propagate this error up, or use expect

Suggested change

	TrieNode::Edge { child, path: EdgePath { len: length.try_into().unwrap(), value: path } }
	TrieNode::Edge { child, path: EdgePath { len: length.try_into().expect("length must be a valid integer"), value: path } }