Implement keetanetwork-block crate with block and operation types by mamonet · Pull Request #3 · KeetaNetwork/node-rs

mamonet · 2026-01-10T19:34:53Z

This PR adds the following features:

Shared keetanetwork-block crate for block and operation types
Zero-copy types with lifetime parameters for no_std environments
Includes all 11 operation types matching the protocol spec
Add address validation based on algorithm prefix (secp256k1/Ed25519/secp256r1) [REMOVED - Duplicate with account code]

TODO

Vote types (X.509 certificate-based)
VoteStaple types
MultiSigSignerInfo (nested multisig)

keetanetwork-block/src/types.rs

Copilot

Pull request overview

This PR introduces a new keetanetwork-block crate that provides foundational block and operation type definitions for the Keeta blockchain. The implementation emphasizes zero-copy design with lifetime parameters to support no_std environments while maintaining flexibility through optional alloc and std features.

Changes:

Added shared type definitions for blocks (V1 and V2) and all 11 blockchain operations
Implemented address validation based on algorithm prefix (secp256k1, Ed25519, secp256r1)
Configured feature flags to support no_std, alloc, and std environments

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 4 comments.

File	Description
keetanetwork-block/Cargo.toml	Defines feature flags for std/alloc/no_std support and removes unused dependencies
keetanetwork-block/src/lib.rs	Exports public API with conditional compilation for alloc-dependent types
keetanetwork-block/src/types.rs	Implements all block types, operation structures, and address validation logic

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

keetanetwork-block/src/types.rs

mamonet · 2026-01-11T07:56:44Z

@rkeene do you suggest to put the remaining types here or in different PR?

keetanetwork-block/src/types.rs

rkeene · 2026-01-12T20:09:04Z

@rkeene do you suggest to put the remaining types here or in different PR?

I think it's fine to include that change in this PR since it's a dependency -- otherwise you would need to re-org and re-base but without much gained from it here.

keetanetwork-block/src/types.rs

sephynox · 2026-01-13T00:18:40Z

keetanetwork-block/src/types.rs

+pub enum AdjustMethodRelative {
+	Add,
+	Remove,
+	Unknown(u8),
+}


I am not sure this is a good approach. We should just return Result instead when using an unsupported AdjustMethod.

keetanetwork-block/src/types.rs

sephynox · 2026-01-13T00:21:25Z

keetanetwork-block/src/types.rs

+	pub fn new(header: BlockHeader<'a>, operations: Vec<Operation<'a>>) -> Self {
+		Self { version: BlockVersion::V1, header, operations }
+	}
+
+	/// Create a new V2 block
+	pub fn new_v2(header: BlockHeader<'a>, operations: Vec<Operation<'a>>) -> Self {
+		Self { version: BlockVersion::V2, header, operations }
+	}


We may want a KeetaBlockBuilder instead of new_v*

let block = KeetaBlockBuilder::from(BlockVersion::V*) .with_block_header(header) .with_operations(operations) .build();

Something like so.

I added KeetaBlockBuilder but I set header in constructor since it's not optional for both versions

Builder should be in a draft PR and not here

keetanetwork-block/src/types.rs

mamonet · 2026-01-19T10:28:57Z

I think the changes covers the keetanetwork-block work we scoped.

Summary of implementation:

DER encoding/decoding: support for all types (V1/V2 blocks, operations, signatures) with support for no_alloc environments
Multisig support: Added signer types in addition to vote & certificate types
JS SDK compatibility: Roundtrip tests verify byte-exact encoding against real mainnet blocks and manually constructed test vectors

Unrelated Changes

Fixed clippy useless_vec warning in keetanetwork-x509/src/utils.rs (replaced vec![] with array literal in test)

All tests passing. Ready for review.

keetanetwork-block/src/types.rs

rkeene · 2026-01-21T19:15:11Z

keetanetwork-block/src/types.rs

+#[derive(Debug, Clone, Copy, Sequence)]
+pub struct TokenRate<'a> {
+	/// Token public key
+	pub token: Bytes<'a>,


Why do we use undifferentiated Bytes here instead of something higher-level and more specific (account) ?

This layer mirrors the ASN.1 (all OCTET STRING); semantic validation happens upstream in TS via assertKeyType()
can add aliases for clarity: pub type TokenId<'a> = Bytes<'a>; No compile-time safety, but documents intent. Prefer newtype wrappers instead?

@sephynox @mamonet It still seems like it should be a type with an assertKeyType() method rather than undifferentiated bytes

We could use the existing types but we would need to make those crates partially no_std.

a newtype wrapper would be better, something like:

pub struct TokenId<'a>(Bytes<'a>); impl<'a> TokenId<'a> { // validate algorithm prefix and length pub fn assert_key_type(&self) -> Result<(), Error> {} pub fn as_bytes(&self) -> &'a [u8] { self.0.as_bytes() } }

I will implement these types for Bytes fields.

Will be resolved when using account crate

keetanetwork-block/src/types.rs

rkeene · 2026-01-21T19:22:00Z

keetanetwork-block/src/types.rs

+	pub signature: &'a [u8],
+}
+
+/// Vote staple - bundles blocks with their votes


Vote Staples make few other guarantees as well:

All votes have the same set of block hashes in the same order

All blocks are referenced by the votes

All blocks referenced in the votes are present

All votes are of the same level of permanence (temporary or permanent)

Interesting design for packaging - I'm familiar with OCSP stapling, which bundles certificate status proofs so verifiers don't need extra roundtrips, similar concept here with votes and blocks.
These invariants make sense for that model, want me to add them as doc comments on VoteStaple, implement a validate() method or both?

Either is fine at this point, but the validation is important to do at some point because it's not a valid vote staple unless those conditions are met

Makes sense. Before jumping into the implementation, it might be worth discussing how vote staple validation should behave under different circumstances — e.g., should validate() be called on construction (ensuring invalid staples can't exist), on deserialization from the network, or deferred to the consumer? The answer likely affects where the method lives and what it returns. Happy to sync on this and then implement accordingly.

sonarqubecloud · 2026-02-05T16:51:26Z

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
91.2% Coverage on New Code
0.7% Duplication on New Code

See analysis details on SonarQube Cloud

sephynox · 2026-02-11T21:10:59Z

keetanetwork-block/src/block.rs

+		// network
+		let network: u64 = seq.decode()?;
+
+		// subnet
+		let subnet = decode_null_or_integer(seq)?;
+
+		// date
+		let date = read_generalized_time_bytes(seq)?;
+
+		// account
+		let account: OctetStringRef = seq.decode()?;
+
+		// signer
+		let signer = decode_v1_signer(seq)?;
+
+		// previous
+		let previous: OctetStringRef = seq.decode()?;
+
+		// operations
+		let operations = decode_operations(seq)?;
+
+		// signature
+		let signature: OctetStringRef = seq.decode()?;


These comments are pointless.

sephynox · 2026-02-11T21:11:18Z

keetanetwork-block/src/block.rs

+		// network
+		let network: u64 = seq.decode()?;
+
+		// date
+		let date = read_generalized_time_bytes(seq)?;
+
+		// purpose
+		let purpose_val: u8 = seq.decode()?;
+		let purpose = BlockPurpose::try_from(purpose_val).map_err(|_| Tag::Integer.value_error())?;
+
+		// account
+		let account: OctetStringRef = seq.decode()?;
+
+		// signer
+		let signer = decode_v2_signer(seq)?;
+
+		// previous
+		let previous: OctetStringRef = seq.decode()?;
+
+		// operations
+		let operations = decode_operations(seq)?;
+
+		// signatures
+		let signatures = decode_signatures(seq)?;


These comments are pointless.

sephynox · 2026-02-11T21:12:18Z

keetanetwork-block/src/block.rs

+
+		// date
+		let date_len = encode_generalized_time_len(self.header.date)?;
+
+		// account
+		let account_len = OctetStringRef::new(self.header.account)?.encoded_len()?;
+
+		// signer
+		let signer_len = encode_signer_len(&self.header.signer)?;
+
+		// previous
+		let previous_len = OctetStringRef::new(self.header.previous)?.encoded_len()?;
+
+		// operations
+		let ops_len = self.operations_encoded_len()?;
+
+		// signature
+		let sig_len = if !self.signatures.is_empty() {
+			OctetStringRef::new(self.signatures[0])?.encoded_len()?
+		} else {
+			Length::ZERO


These comments are pointless.

sephynox · 2026-02-11T21:12:42Z

keetanetwork-block/src/block.rs

+		// network
+		let network_len = self.header.network.encoded_len()?;
+
+		// date
+		let date_len = encode_generalized_time_len(self.header.date)?;
+
+		// purpose
+		let purpose_len = (self.header.purpose as u8).encoded_len()?;
+
+		// account
+		let account_len = OctetStringRef::new(self.header.account)?.encoded_len()?;
+
+		// signer
+		let signer_len = encode_signer_len(&self.header.signer)?;
+
+		// previous
+		let previous_len = OctetStringRef::new(self.header.previous)?.encoded_len()?;
+
+		// operations
+		let ops_len = self.operations_encoded_len()?;
+
+		// signatures
+		let sig_len = self.signatures_encoded_len()?;
+
+		network_len + date_len + purpose_len + account_len + signer_len + previous_len + ops_len + sig_len


These comments are pointless.

sephynox · 2026-02-11T21:14:18Z

keetanetwork-block/src/block.rs

+#[cfg(any(feature = "alloc", feature = "std"))]
+fn encode_generalized_time_len(date_bytes: &[u8]) -> der::Result<Length> {
+	let content_len = Length::try_from(date_bytes.len())?;
+	Header::new(Tag::GeneralizedTime, content_len)?.encoded_len() + content_len
+}
+
+/// Encodes `GeneralizedTime` from raw bytes.
+#[cfg(any(feature = "alloc", feature = "std"))]
+fn encode_generalized_time(date_bytes: &[u8], writer: &mut impl Writer) -> der::Result<()> {
+	let content_len = Length::try_from(date_bytes.len())?;
+	Header::new(Tag::GeneralizedTime, content_len)?.encode(writer)?;
+	writer.write(date_bytes)
+}


One mutates and the other returns but you would not know this from this naming scheme.

sephynox · 2026-02-11T21:15:15Z

keetanetwork-block/src/metadata.rs

+	if let Some(value) = raw.asset_id {
+		let bytes = value.as_bytes();
+		let copy_len = bytes.len().min(MAX_FIELD_LEN);
+		result.asset_id[..copy_len].copy_from_slice(&bytes[..copy_len]);
+		result.asset_id_len = copy_len;
+		found_any = true;
+	}
+
+	if let Some(value) = raw.authority {
+		let bytes = value.as_bytes();
+		let copy_len = bytes.len().min(MAX_FIELD_LEN);
+		result.authority[..copy_len].copy_from_slice(&bytes[..copy_len]);
+		result.authority_len = copy_len;
+		found_any = true;
+	}
+
+	if let Some(value) = raw.symbol {
+		let bytes = value.as_bytes();
+		let copy_len = bytes.len().min(MAX_FIELD_LEN);
+		result.symbol[..copy_len].copy_from_slice(&bytes[..copy_len]);
+		result.symbol_len = copy_len;
+		found_any = true;
+	}


You could probably DRY this.

sephynox · 2026-02-11T21:15:55Z

keetanetwork-block/src/metadata.rs

+	#[test]
+	fn test_decode_metadata_unknown_fields_only() {
+		let mut buf = [0u8; 512];
+
+		let json = r#"{"foo":"bar","baz":123}"#;
+		let b64 = base64_encode_for_test(json.as_bytes());
+
+		match decode_metadata(&b64, &mut buf) {
+			MetadataDisplay::Unknown => {}
+			_ => panic!("Expected Unknown variant"),
+		}
+	}
+
+	#[test]
+	fn test_decode_metadata_invalid_base64() {
+		let mut buf = [0u8; 100];
+		match decode_metadata("not-valid-base64!!!", &mut buf) {
+			MetadataDisplay::Invalid => {}
+			_ => panic!("Expected Invalid variant"),
+		}
+	}
+
+	#[test]
+	fn test_decode_metadata_invalid_json() {
+		let mut buf = [0u8; 100];
+		let b64 = base64_encode_for_test(b"not json at all");
+
+		match decode_metadata(&b64, &mut buf) {
+			MetadataDisplay::Invalid => {}
+			_ => panic!("Expected Invalid variant"),
+		}
+	}


You could data-drive these tests.

sephynox · 2026-02-11T21:18:07Z

keetanetwork-block/tests/sdk_compat.rs

+#[test]
+fn test_malformed_empty_input() {
+	let result = KeetaBlock::from_der(&[]);
+	assert!(result.is_err(), "Empty input should fail to parse");
+}
+
+/// Test that truncated data returns an error
+#[test]
+fn test_malformed_truncated_data() {
+	// Take a valid sample and truncate it
+	let valid = samples::SET_REP;
+	let truncated = &valid[..valid.len() / 2];
+	let result = KeetaBlock::from_der(truncated);
+	assert!(result.is_err(), "Truncated data should fail to parse");
+}
+
+/// Test that invalid outer tag returns an error
+#[test]
+fn test_malformed_invalid_tag() {
+	// Use OCTET STRING tag (0x04) instead of SEQUENCE (0x30) or [1] (0xa1)
+	let invalid = [0x04, 0x05, 0x01, 0x02, 0x03, 0x04, 0x05];
+	let result = KeetaBlock::from_der(&invalid);
+	assert!(result.is_err(), "Invalid outer tag should fail to parse");
+}
+
+/// Test that length exceeding data returns an error
+#[test]
+fn test_malformed_length_overflow() {
+	// SEQUENCE with length 0xFF but only 5 bytes of data
+	let invalid = [0x30, 0x81, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05];
+	let result = KeetaBlock::from_der(&invalid);
+	assert!(result.is_err(), "Length overflow should fail to parse");
+}
+
+/// Test that extra trailing bytes are handled
+#[test]
+fn test_malformed_trailing_data() {
+	// Take a valid sample and append extra bytes
+	let valid = samples::SET_REP;
+	let mut with_trailing = valid.to_vec();


You can probably data-drive all of these KeetaBlock::from_der tests.

Add Keeta block and operation types for DER parsing

cef22d4

rkeene reviewed Jan 10, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

ezraripps requested a review from Copilot January 10, 2026 20:07

Copilot started reviewing on behalf of ezraripps January 10, 2026 20:08 View session

Copilot AI reviewed Jan 10, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

keetanetwork-block/src/types.rs Show resolved Hide resolved

keetanetwork-block/src/types.rs Show resolved Hide resolved

mamonet added 4 commits January 10, 2026 23:19

Store DER integers as &'a [u8]

788a2a4

Remove address validation exports from public API

c7e1ce0

Remove #[repr(u8)] from enums in types.rs

147ab9c

Fix formatting for block crate

a17c01b

sephynox assigned mamonet Jan 12, 2026

sephynox self-requested a review January 12, 2026 18:59

sephynox added the enhancement New feature or request label Jan 12, 2026

mamonet mentioned this pull request Jan 12, 2026

Using rasn for Keeta block types #4

Open

sephynox reviewed Jan 12, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

keetanetwork-block/src/types.rs Show resolved Hide resolved

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

ezraripps reviewed Jan 12, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

ezraripps reviewed Jan 12, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

sephynox reviewed Jan 13, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

sephynox reviewed Jan 13, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

sephynox reviewed Jan 13, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

sephynox reviewed Jan 13, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

sephynox reviewed Jan 13, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

mamonet added 3 commits January 13, 2026 16:59

Use typed integers and fallible enum parsing in block types

8e550f2

Add KeetaBlockBuilder and replace U128 with byte slices

ce141db

Add signatures to KeetaBlock

0f2914b

ezraripps reviewed Jan 14, 2026

View reviewed changes

keetanetwork-block/src/types.rs Outdated Show resolved Hide resolved

Add multisig signer types for V2 blocks

82e515f

mamonet added 9 commits January 15, 2026 15:48

Add vote types and separate rate/value swap types

880d5d2

Add DER encoding/decoding support with derive macros

711bbf7

Add test coverage

27650cf

Export vote and certificate types from lib.rs

032f569

Add KeetaBlock DER encoding/decoding with SDK compatibility tests

4135c36

Fix clippy expect_fun_call warnings in SDK compat tests

2bdcd25

Add multisig signer iteration support with SignersIter

d3e8baf

Fix clippy vec_init_then_push warning in multisig test

0ca1272

Embed test samples and add malformed input tests

c78763f

ezraripps requested review from ezraripps, rkeene and sephynox January 21, 2026 18:25

mamonet added 2 commits January 21, 2026 19:33

Fix clippy useless_vec warning in x509 utils test

883d2cc

Fix rustdoc warnings for bracket notation in docs

8822860

rkeene reviewed Jan 21, 2026

View reviewed changes

mamonet added 5 commits January 22, 2026 15:24

Replace manual DER parsing with SliceReader in SignersIter

2881b80

Add extract_operations_slice for block operations parsing

3a34af0

Add keetanetwork-permissions crate with permission bit definitions

10a5c8c

Add keetanetwork-permissions to workspace members

374bba1

Add metadata module and consolidate permissions into keetanetwork-block

9d76887

sephynox reviewed Feb 11, 2026

View reviewed changes

Conversation

mamonet commented Jan 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

TODO

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

mamonet commented Jan 11, 2026

Uh oh!

Uh oh!

Uh oh!

Uh oh!

rkeene commented Jan 12, 2026

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

mamonet commented Jan 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary of implementation:

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sonarqubecloud bot commented Feb 5, 2026

Quality Gate passed

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mamonet commented Jan 10, 2026 •

edited

Loading

mamonet commented Jan 19, 2026 •

edited

Loading