Merge branch 'main' into other
Some checks are pending
Deny / audit (push) Waiting to run

This commit is contained in:
hinto.janai 2025-01-16 08:36:11 -05:00
commit 1c3f1b16a0
No known key found for this signature in database
GPG key ID: D47CE05FA175A499
8 changed files with 69 additions and 46 deletions

View file

@ -46,6 +46,35 @@ jobs:
- name: Spell Check
uses: crate-ci/typos@master
# Run 32-bit WASM support check separately.
wasm-32-bit-support:
runs-on: ubuntu-latest
strategy:
matrix:
# The list of crates to check for WASM 32 bit support
# TODO: check features.
crate: [
cuprate-epee-encoding,
cuprate-rpc-types,
cuprate-fixed-bytes,
]
steps:
- name: Checkout
uses: actions/checkout@v4
with:
submodules: recursive
- name: Install Rust
uses: dtolnay/rust-toolchain@master
with:
toolchain: stable
targets: wasm32-unknown-unknown
- name: Build WASM 32-bit
run: cargo build --target wasm32-unknown-unknown -p ${{ matrix.crate }}
# All other CI.
ci:
runs-on: ${{ matrix.os }}

1
Cargo.lock generated
View file

@ -884,7 +884,6 @@ version = "0.5.0"
dependencies = [
"bytes",
"cuprate-fixed-bytes",
"cuprate-helper",
"cuprate-hex",
"hex",
"paste",

View file

@ -1,14 +1,15 @@
-----BEGIN PGP PUBLIC KEY BLOCK-----
mDMEZb0y4RYJKwYBBAHaRw8BAQdAvMid+QsSxLULIkKPLf0XWgPxaoG89qPNiQ4S
fXH0BfW0VlN5bnRoZXRpY0JpcmQ0NSAoQ3VwcmF0ZSdzIGRldmVsb3BlcikgPHNv
bWVvbmVlbHNlLmlzX29uLmdpdGh1Yi5yaW83eEBzaW1wbGVsb2dpbi5jb20+iJME
ExYKADsWIQQEmOfWc9FTBiAKoHnHaXP3SFIeEQUCZb0y4QIbAwULCQgHAgIiAgYV
CgkICwIEFgIDAQIeBwIXgAAKCRDHaXP3SFIeEUx+AQDYd7t75+V4/aSTczLxMGuT
A84qGRuYNStXUJzjV8F21wD/YVlybZcr9dDQ/+YOgh5aXBzo+oGm+XhhSbI3QdIX
LAC4OARlvTLhEgorBgEEAZdVAQUBAQdAgRoSFUmnCqETElyry97kFwsdzlNyldk2
ZPgH9J4fCHwDAQgHiHgEGBYKACAWIQQEmOfWc9FTBiAKoHnHaXP3SFIeEQUCZb0y
4QIbDAAKCRDHaXP3SFIeETDSAP4k8+jUaStnjrkzN1jvRg136qNfwe8ZzjrsWJ0n
FOS8zAEA/fwRjRyvEP28KJNiKdyhDYWYJTpyLGTiPP8b43NsHAM=
=gqqy
mDMEZ4GuPxYJKwYBBAHaRw8BAQdAQFWzCHuyJ9jWtUDQayE3MmWVREIusc2MVuzY
dYetE+20V1N5bnRoZXRpY0JpcmQgKEN1cHJhdGUgZGV2ZWxvcGVyLCBNb25lcm8g
Y29udHJpYnV0b3IpIDxzeW50aGV0aWNiaXJkeG1yQHByb3Rvbm1haWwuY29tPoiZ
BBMWCgBBFiEEVnEONDQa+3BwEBfopfyUokH0BgwFAmeBrj8CGwMFCQPCZwAFCwkI
BwICIgIGFQoJCAsCBBYCAwECHgcCF4AACgkQpfyUokH0BgxXnAEArUNk7MHclNDq
Bt2NdKF4HUjstpascmONWDpS/m7MFtsBAJTQKja7NiJ6qrjgKDYoLGSDSmZr6hlb
RMWf7taE444GuDgEZ4GuPxIKKwYBBAGXVQEFAQEHQMN4rVFJjFgnFvm+RVCaIgZ3
59nzmAPrMWG1MEPz1k8AAwEIB4h+BBgWCgAmFiEEVnEONDQa+3BwEBfopfyUokH0
BgwFAmeBrj8CGwwFCQPCZwAACgkQpfyUokH0Bgwt+QD/TuE65+AAS3nsnhhT9kgX
9AfP3Ns3GDAcI7DkNBrEOF8A/0nZaezH3keuHTzsmRblV4nUD6Yqn4bbs8BGH4Ox
k6EG
=3x7Z
-----END PGP PUBLIC KEY BLOCK-----

View file

@ -15,7 +15,6 @@ default = ["std"]
std = ["dep:thiserror", "bytes/std", "cuprate-fixed-bytes/std"]
[dependencies]
cuprate-helper = { workspace = true, default-features = false, features = ["cast"] }
cuprate-fixed-bytes = { workspace = true, default-features = false }
cuprate-hex = { workspace = true, default-features = false }

View file

@ -69,8 +69,6 @@ use core::str::from_utf8 as str_from_utf8;
use bytes::{Buf, BufMut, Bytes, BytesMut};
use cuprate_helper::cast::{u64_to_usize, usize_to_u64};
pub mod container_as_blob;
pub mod error;
mod io;
@ -89,7 +87,7 @@ pub use varint::{read_varint, write_varint};
/// this binary serialization format.
const HEADER: &[u8] = b"\x01\x11\x01\x01\x01\x01\x02\x01\x01";
/// The maximum length a byte array (marked as a string) can be.
const MAX_STRING_LEN_POSSIBLE: u64 = 2000000000;
const MAX_STRING_LEN_POSSIBLE: usize = 2000000000;
/// The maximum depth of skipped objects.
const MAX_DEPTH_OF_SKIPPED_OBJECTS: u8 = 20;
/// The maximum number of fields in an object.
@ -248,7 +246,7 @@ pub fn write_bytes<T: AsRef<[u8]>, B: BufMut>(t: T, w: &mut B) -> Result<()> {
let bytes = t.as_ref();
let len = bytes.len();
write_varint(usize_to_u64(len), w)?;
write_varint(len, w)?;
if w.remaining_mut() < len {
return Err(Error::IO("Not enough capacity to write bytes"));
@ -292,7 +290,7 @@ where
I: Iterator<Item = T> + ExactSizeIterator,
B: BufMut,
{
write_varint(usize_to_u64(iterator.len()), w)?;
write_varint(iterator.len(), w)?;
for item in iterator {
item.write(w)?;
}
@ -337,7 +335,7 @@ fn skip_epee_value<B: Buf>(r: &mut B, skipped_objects: &mut u8) -> Result<()> {
if let Some(size) = marker.inner_marker.size() {
let bytes_to_skip = size
.checked_mul(u64_to_usize(len))
.checked_mul(len.try_into()?)
.ok_or(Error::Value("List is too big".to_string()))?;
return advance(bytes_to_skip, r);
};
@ -355,7 +353,7 @@ fn skip_epee_value<B: Buf>(r: &mut B, skipped_objects: &mut u8) -> Result<()> {
| InnerMarker::U8
| InnerMarker::Bool => unreachable!("These types are constant size."),
InnerMarker::String => {
let len = u64_to_usize(read_varint(r)?);
let len = read_varint(r)?;
advance(len, r)?;
}
InnerMarker::Object => {

View file

@ -7,7 +7,6 @@ use core::fmt::Debug;
use bytes::{Buf, BufMut, Bytes, BytesMut};
use cuprate_fixed_bytes::{ByteArray, ByteArrayVec};
use cuprate_helper::cast::u64_to_usize;
use cuprate_hex::{Hex, HexVec};
use crate::{
@ -68,7 +67,7 @@ impl<T: EpeeObject> EpeeValue for Vec<T> {
"Marker is not sequence when a sequence was expected",
));
}
let len = u64_to_usize(read_varint(r)?);
let len = read_varint(r)?;
let individual_marker = Marker::new(marker.inner_marker);
@ -169,8 +168,6 @@ impl EpeeValue for Vec<u8> {
return Err(Error::Format("Byte array exceeded max length"));
}
let len = u64_to_usize(len);
if r.remaining() < len {
return Err(Error::IO("Not enough bytes to fill object"));
}
@ -207,8 +204,6 @@ impl EpeeValue for Bytes {
return Err(Error::Format("Byte array exceeded max length"));
}
let len = u64_to_usize(len);
if r.remaining() < len {
return Err(Error::IO("Not enough bytes to fill object"));
}
@ -242,8 +237,6 @@ impl EpeeValue for BytesMut {
return Err(Error::Format("Byte array exceeded max length"));
}
let len = u64_to_usize(len);
if r.remaining() < len {
return Err(Error::IO("Not enough bytes to fill object"));
}
@ -275,13 +268,11 @@ impl<const N: usize> EpeeValue for ByteArrayVec<N> {
return Err(Error::Format("Marker does not match expected Marker"));
}
let len = read_varint(r)?;
let len = read_varint::<_, usize>(r)?;
if len > MAX_STRING_LEN_POSSIBLE {
return Err(Error::Format("Byte array exceeded max length"));
}
let len = u64_to_usize(len);
if r.remaining() < len {
return Err(Error::IO("Not enough bytes to fill object"));
}
@ -311,7 +302,7 @@ impl<const N: usize> EpeeValue for ByteArray<N> {
return Err(Error::Format("Marker does not match expected Marker"));
}
let len = u64_to_usize(read_varint(r)?);
let len = read_varint::<_, usize>(r)?;
if len != N {
return Err(Error::Format("Byte array has incorrect length"));
}
@ -378,7 +369,7 @@ impl<const N: usize> EpeeValue for Vec<[u8; N]> {
));
}
let len = u64_to_usize(read_varint(r)?);
let len = read_varint(r)?;
let individual_marker = Marker::new(marker.inner_marker);
@ -461,7 +452,7 @@ macro_rules! epee_seq {
));
}
let len = u64_to_usize(read_varint(r)?);
let len = read_varint(r)?;
let individual_marker = Marker::new(marker.inner_marker.clone());

View file

@ -12,14 +12,14 @@ const FITS_IN_FOUR_BYTES: u64 = 2_u64.pow(32 - SIZE_OF_SIZE_MARKER) - 1;
/// ```rust
/// use cuprate_epee_encoding::read_varint;
///
/// assert_eq!(read_varint(&mut [252].as_slice()).unwrap(), 63);
/// assert_eq!(read_varint(&mut [1, 1].as_slice()).unwrap(), 64);
/// assert_eq!(read_varint(&mut [253, 255].as_slice()).unwrap(), 16_383);
/// assert_eq!(read_varint(&mut [2, 0, 1, 0].as_slice()).unwrap(), 16_384);
/// assert_eq!(read_varint(&mut [254, 255, 255, 255].as_slice()).unwrap(), 1_073_741_823);
/// assert_eq!(read_varint(&mut [3, 0, 0, 0, 1, 0, 0, 0].as_slice()).unwrap(), 1_073_741_824);
/// assert_eq!(read_varint::<_, u64>(&mut [252].as_slice()).unwrap(), 63);
/// assert_eq!(read_varint::<_, u64>(&mut [1, 1].as_slice()).unwrap(), 64);
/// assert_eq!(read_varint::<_, u64>(&mut [253, 255].as_slice()).unwrap(), 16_383);
/// assert_eq!(read_varint::<_, u64>(&mut [2, 0, 1, 0].as_slice()).unwrap(), 16_384);
/// assert_eq!(read_varint::<_, u64>(&mut [254, 255, 255, 255].as_slice()).unwrap(), 1_073_741_823);
/// assert_eq!(read_varint::<_, u64>(&mut [3, 0, 0, 0, 1, 0, 0, 0].as_slice()).unwrap(), 1_073_741_824);
/// ```
pub fn read_varint<B: Buf>(r: &mut B) -> Result<u64> {
pub fn read_varint<B: Buf, T: TryFrom<u64>>(r: &mut B) -> Result<T> {
if !r.has_remaining() {
return Err(Error::IO("Not enough bytes to build VarInt"));
}
@ -35,7 +35,8 @@ pub fn read_varint<B: Buf>(r: &mut B) -> Result<u64> {
for i in 1..len {
vi |= u64::from(r.get_u8()) << (((i - 1) * 8) + 6);
}
Ok(vi)
vi.try_into().map_err(|_| Error::IO("VarInt is too big"))
}
/// Write an epee variable sized number into `w`.
@ -58,7 +59,12 @@ pub fn read_varint<B: Buf>(r: &mut B) -> Result<u64> {
/// assert_eq!(buf.as_slice(), expected_bytes);
/// }
/// ```
pub fn write_varint<B: BufMut>(number: u64, w: &mut B) -> Result<()> {
pub fn write_varint<B: BufMut, T: TryInto<u64>>(number: T, w: &mut B) -> Result<()> {
let number = number
.try_into()
.map_err(|_| "Tried to write a varint bigger than 64-bits")
.unwrap();
let size_marker = match number {
0..=FITS_IN_ONE_BYTE => 0,
64..=FITS_IN_TWO_BYTES => 1,
@ -101,7 +107,7 @@ mod tests {
}
fn assert_varint_val(mut varint: &[u8], val: u64) {
assert_eq!(read_varint(&mut varint).unwrap(), val);
assert_eq!(read_varint::<_, u64>(&mut varint).unwrap(), val);
}
#[test]

View file

@ -134,8 +134,8 @@ define_request_and_response! {
start_height: u64,
current_height: u64,
output_indices: Vec<BlockOutputIndices> = default::<Vec<BlockOutputIndices>>(), "default",
daemon_time: u64,
pool_info: PoolInfo,
daemon_time: u64 = default::<u64>(), "default",
pool_info: PoolInfo = default::<PoolInfo>(), "default",
}
}