certusone
/
wormhole
mirror of https://github.com/certusone/wormhole.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

sdk/rust: Remove `*_with_payload` methods 

The RawMessage type provides a more flexible way to handle trailing
payloads so replace all usage of the `*_with_payload` functions to use
`RawMessage` instead.

There should be no functional change.
This commit is contained in:
Chirantan Ekbote 2023-01-13 18:26:15 +09:00 committed by Chirantan Ekbote
parent 3c6702b6f7
commit 421a030dca
4 changed files with 30 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
cosmwasm/contracts/wormchain-accounting/src/contract.rs
View File

@ -14,6 +14,7 @@ use cosmwasm_std::{
};
use cw2::set_contract_version;
use cw_storage_plus::Bound;
use serde_wormhole::RawMessage;
use tinyvec::{Array, TinyVec};
use wormhole::{
token::{Action, GovernancePacket, Message},
@ -183,7 +184,7 @@ fn handle_observation(
return Ok(None);
}
let (msg, _) = serde_wormhole::from_slice_with_payload(&o.payload)
let (msg, _) = serde_wormhole::from_slice::<(Message, &RawMessage)>(&o.payload)
.context("failed to parse observation payload")?;
let tx_data = match msg {
Message::Transfer {
@ -322,7 +323,7 @@ fn submit_vaas(
}
fn handle_vaa(mut deps: DepsMut<WormholeQuery>, vaa: Binary) -> anyhow::Result<Event> {
let (header, data) = serde_wormhole::from_slice_with_payload::<Header>(&vaa)
let (header, data) = serde_wormhole::from_slice::<(Header, &RawMessage)>(&vaa)
.context("failed to parse VAA header")?;
ensure!(header.version == 1, "unsupported VAA version");
@ -342,7 +343,7 @@ fn handle_vaa(mut deps: DepsMut<WormholeQuery>, vaa: Binary) -> anyhow::Result<E
.map(|d| d.secp256k_hash.to_vec().into())
.context("failed to calculate digest for VAA body")?;
let (body, payload) = serde_wormhole::from_slice_with_payload::<Body<()>>(data)
let body = serde_wormhole::from_slice::<Body<&RawMessage>>(data)
.context("failed to parse VAA body")?;
let digest_key = DIGESTS.key((
@ -365,11 +366,11 @@ fn handle_vaa(mut deps: DepsMut<WormholeQuery>, vaa: Binary) -> anyhow::Result<E
let evt = if body.emitter_chain == Chain::Solana
&& body.emitter_address == wormhole::GOVERNANCE_EMITTER
{
let govpacket =
serde_wormhole::from_slice(payload).context("failed to parse governance packet")?;
let govpacket = serde_wormhole::from_slice(body.payload)
.context("failed to parse governance packet")?;
handle_governance_vaa(deps.branch(), body.with_payload(govpacket))?
} else {
let (msg, _) = serde_wormhole::from_slice_with_payload(payload)
let (msg, _) = serde_wormhole::from_slice::<(_, &RawMessage)>(body.payload)
.context("failed to parse tokenbridge message")?;
handle_tokenbridge_vaa(deps.branch(), body.with_payload(msg))?
};

13
sdk/rust/core/src/token.rs
View File

@ -68,7 +68,6 @@ pub enum Message {
/// ```
/// # fn example() -> anyhow::Result<()> {
/// # use wormhole::{Address, Amount, Chain, vaa::Signature, GOVERNANCE_EMITTER};
/// use wormhole::{token::Message, Vaa};
/// #
/// # let data = [
/// # 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xb0, 0x72, 0x50, 0x5b, 0x5b, 0x99, 0x9c, 0x1d,
@ -94,10 +93,12 @@ pub enum Message {
/// # 0xfa, 0x5e, 0x70, 0xea, 0x36, 0xa2, 0x82, 0x37, 0x1d, 0x46, 0x81, 0x94, 0x10, 0x34, 0xb1,
/// # 0xad, 0x0f, 0x4b, 0xc9, 0x17, 0x1e, 0x91, 0x25, 0x11,
/// # ];
/// use serde_wormhole::RawMessage;
/// use wormhole::{token::Message, Vaa};
///
/// let (msg, payload) = serde_wormhole::from_slice_with_payload::<Vaa<Message>>(&data)?;
/// let (msg, payload) = serde_wormhole::from_slice::<(Vaa<Message>, &RawMessage)>(&data)?;
/// assert!(matches!(msg.payload, Message::TransferWithPayload { .. }));
/// assert_eq!(&data[256..], payload);
/// assert_eq!(&data[256..], payload.get());
/// #
/// # Ok(())
/// # }
@ -458,6 +459,8 @@ mod governance_packet_impl {
#[cfg(test)]
mod test {
use serde_wormhole::RawMessage;
use crate::{vaa::Signature, Vaa, GOVERNANCE_EMITTER};
use super::*;
@ -585,9 +588,9 @@ mod test {
};
assert_eq!(&payload[..133], &serde_wormhole::to_vec(&msg).unwrap());
let (actual, data) = serde_wormhole::from_slice_with_payload(&payload).unwrap();
let (actual, data) = serde_wormhole::from_slice::<(_, &RawMessage)>(&payload).unwrap();
assert_eq!(msg, actual);
assert_eq!(&payload[133..], data);
assert_eq!(&payload[133..], data.get());
let mut encoded = serde_json::to_vec(&msg).unwrap();
encoded.extend_from_slice(&payload[133..]);

16
sdk/rust/core/src/vaa.rs
View File

@ -277,6 +277,8 @@ impl<P: Serialize> Body<P> {
#[cfg(test)]
mod test {
use serde_wormhole::RawMessage;
use super::*;
#[test]
@ -318,14 +320,11 @@ mod test {
]),
sequence: 0,
consistency_level: 1,
payload: (),
payload: RawMessage::new(&buf[123..]),
};
let (actual, payload) = serde_wormhole::from_slice_with_payload(&buf).unwrap();
assert_eq!(vaa, actual);
assert_eq!(bstr::B("From: evm0\\nMsg: Hello World!"), payload);
assert_eq!(&buf[..123], &serde_wormhole::to_vec(&vaa).unwrap());
assert_eq!(vaa, serde_wormhole::from_slice(&buf).unwrap());
assert_eq!(&buf[..], &serde_wormhole::to_vec(&vaa).unwrap());
}
#[test]
@ -351,9 +350,8 @@ mod test {
assert_eq!(d1, d2);
let (partial, payload) =
serde_wormhole::from_slice_with_payload::<Body<()>>(&data).unwrap();
let d3 = partial.digest_with_payload(payload).unwrap();
let partial = serde_wormhole::from_slice::<Body<&RawMessage>>(&data).unwrap();
let d3 = partial.digest().unwrap();
assert_eq!(d1, d3);
}

38
sdk/rust/serde_wormhole/src/lib.rs
View File

@ -143,19 +143,6 @@ pub fn from_reader<R: Read, T: DeserializeOwned>(mut r: R) -> Result<T, Error> {
from_slice(&buf)
}
/// Like `from_reader` but also returns any trailing data in the input buffer after
/// deserialization.
pub fn from_reader_with_payload<R: Read, T: DeserializeOwned>(
mut r: R,
) -> Result<(T, Vec<u8>), Error> {
// We can do something smarter here by making the deserializer generic over the reader (see
// serde_json::Deserializer) but for now this is probably good enough.
let mut buf = Vec::with_capacity(128);
r.read_to_end(&mut buf)?;
from_slice_with_payload(&buf).map(|(v, p)| (v, p.to_vec()))
}
/// Deserialize an instance of type `T` from a byte slice.
pub fn from_slice<'a, T: Deserialize<'a>>(buf: &'a [u8]) -> Result<T, Error> {
let mut deserializer = de::Deserializer::new(buf);
@ -169,15 +156,6 @@ pub fn from_slice<'a, T: Deserialize<'a>>(buf: &'a [u8]) -> Result<T, Error> {
}
}
/// Like `from_slice` but also returns any trailing data in the input buffer after deserialization.
pub fn from_slice_with_payload<'a, T: Deserialize<'a>>(
buf: &'a [u8],
) -> Result<(T, &'a [u8]), Error> {
let mut deserializer = de::Deserializer::new(buf);
T::deserialize(&mut deserializer).map(|v| (v, deserializer.end()))
}
/// Serialize `T` into a byte vector.
pub fn to_vec<T: ?Sized + Serialize>(val: &T) -> Result<Vec<u8>, Error> {
let mut buf = Vec::with_capacity(128);
@ -286,7 +264,7 @@ mod tests {
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct Vaa<'s> {
struct Vaa<'s, P> {
header: Header,
#[serde(borrow)]
signatures: Cow<'s, [Signature]>,
@ -297,7 +275,7 @@ mod tests {
sequence: u64,
consistency_level: u8,
map: BTreeMap<u32, u32>,
payload: GovernancePacket,
payload: P,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@ -348,10 +326,11 @@ mod tests {
}
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct GovernancePacket {
struct GovernancePacket<P> {
module: [u8; 32],
action: Action,
chain: Chain,
payload: P,
}
#[test]
@ -404,21 +383,20 @@ mod tests {
],
action: Action::ContractUpgrade,
chain: Chain::Solana,
payload: RawMessage::new(&[0x3d, 0xab, 0x45, 0xaf, 0x7a, 0x6e, 0x9f, 0x7b]),
},
};
let payload = &[0x3d, 0xab, 0x45, 0xaf, 0x7a, 0x6e, 0x9f, 0x7b];
let mut buf = to_vec(&vaa).unwrap();
buf.extend_from_slice(payload);
let buf = to_vec(&vaa).unwrap();
let (actual, governance_payload) = from_slice_with_payload(&buf).unwrap();
let actual = from_slice(&buf).unwrap();
assert_eq!(vaa, actual);
match actual.payload.action {
Action::ContractUpgrade => {
let expected = 0x3dab_45af_7a6e_9f7b;
let msg: ContractUpgrade = from_slice(governance_payload).unwrap();
let msg: ContractUpgrade = from_slice(actual.payload.payload).unwrap();
assert_eq!(expected, msg.new_contract);
}
_ => panic!("Unexpected action: {:?}", actual.payload.action),