V2 slate versioning enablement

[yeastplume]

Implementation enabling the V2 api to accept differing versions of a Slate as suggested by @bddap in #84. (Would appreciate a bit of a review to see if there's anything here than can be made simpler)

• Adds a VersionedSlate type with methods as suggested in the issue
• Modifies the foreign api's receive_tx function to use a versioned slate
• Adds another conversion of Slate Implementation Itself -> Most recent slate definition. (e.g. Slate->SlateV2 and back), to facilitate the conversion pipeline. Maintenance to include new slate definitions in the conversion pipeline should still remain constant (Slate <-> Most recent (a non-conversion, really) and Most Recent <->2nd most recent will need to be implemented each time there's a new slate version)
• Test to call the foreign RPC api with an older V1 slate and parse the result (which works)

Glad to have this in before 1.1.0 release as knowing this is in place will make slate changes much easier going forward.

Also note this won't compile until a tiny PR is merged in Grin, being created right now.

[bddap]

Higher level question: If slates can always be converted from V0 format, why don't we always use V0 for network communications?

[bddap]

Why match on a wildcard here? Matching on VersionedSlate::V0(_) instead would serve as a reminder to update the function when V3 comes around.

[yeastplume]

Good point, changed

[bddap]

V2?

[yeastplume]

👍

[bddap]

I suggest running similar tests for every slate version.

Most importantly, test that always request_slate.version() == response_slate.version().

Something like this would work:

// easy-jsonrpc generates typesafe client stubs.
// try adding `pub use crate::foreign_rpc::foreign_rpc as foreign_rpc_client;`
// to `api/src/lib.rs` then running `cargo doc --open`
use grin_wallet_api::foreign_rpc_client;

/// call ForeignRpc::receive_tx on vs and return the result
fn receive_tx(vs: VersionedSlate) -> VersionedSlate {
	let dir = tempdir().map_err(|e| format!("{:#?}", e)).unwrap();
	let dir = dir
		.path()
		.to_str()
		.ok_or("Failed to convert tmpdir path to string.".to_owned())
		.unwrap();
	let bound_method = foreign_rpc_client::receive_tx(
		vs,
		None,
		Some("Thanks for saving my dog from that tree, bddap.".into()),
	)
	.unwrap();
	let (call, tracker) = bound_method.call();
	let json_response = run_doctest_foreign(call.as_request(), dir, 5, false)
		.unwrap()
		.unwrap();
	let mut response = easy_jsonrpc::Response::from_json_response(json_response).unwrap();
	tracker.get_return(&mut response).unwrap().unwrap()
}

#[test]
fn version_unchanged() {
	let req: Value = serde_json::from_str(include_str!("slates/v1_req.slate")).unwrap();
	let slate: VersionedSlate = serde_json::from_value(req["params"][0].clone()).unwrap();
	let slate_req: Slate = slate.into();

	assert_eq!(
		receive_tx(VersionedSlate::into_version(
			slate_req.clone(),
			SlateVersion::V0
		))
		.version(),
		SlateVersion::V0
	);

	assert_eq!(
		receive_tx(VersionedSlate::into_version(
			slate_req.clone(),
			SlateVersion::V1
		))
		.version(),
		SlateVersion::V1
	);

	assert_eq!(
		receive_tx(VersionedSlate::into_version(
			slate_req.clone(),
			SlateVersion::V2
		))
		.version(),
		SlateVersion::V2
	);

	// compile time test will remind us to update these tests when updating slate format
	fn _all_versions_tested(vs: VersionedSlate) {
		match vs {
			VersionedSlate::V0(_) => (),
			VersionedSlate::V1(_) => (),
			VersionedSlate::V2(_) => (),
		}
	}
}

[yeastplume]

Thanks for putting this together, I've included this in the last push

[yeastplume]

We're eventually going to drop support for earlier slate versions, and want to be able to make breaking but managed changes to the slate format, so while converting everything to v0 is an option now, it won't be in future. There will also be more consumers of the slate than just us, and V0 is very annoying to work with due to the way fields were serialized as byte arrays.