dev: use sol abi traits (#128)

* use sol_abi traits

* unused imports

* scarb fmt

* Update

src/blobstreamx.cairo

@@ -1,6 +1,7 @@
 #[starknet::contract]
 mod blobstreamx {
     use alexandria_bytes::{Bytes, BytesTrait};
+    use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
     use blobstream_sn::interfaces::{
         DataRoot, TendermintXErrors, IBlobstreamX, IDAOracle, ITendermintX
     };
@@ -147,9 +148,9 @@ mod blobstreamx {
             // load the tuple root at the given index from storage.
             let root: u256 = self.state_data_commitments.read(proof_nonce);
 
-            let mut data_root_bytes = BytesTrait::new_empty();
-            data_root_bytes.append_felt252(data_root.height);
-            data_root_bytes.append_u256(data_root.data_root);
+            let data_root_bytes = BytesTrait::new_empty()
+                .encode_packed(data_root.height)
+                .encode_packed(data_root.data_root);
 
             let (is_proof_valid, _) = merkle_tree::verify(root, @proof, @data_root_bytes);
 
@@ -231,14 +232,14 @@ mod blobstreamx {
                 TendermintXErrors::TargetBlockNotInRange
             );
 
-            let mut input = BytesTrait::new_empty();
-            input.append_u64(latest_block);
-            input.append_u256(latest_header);
-            input.append_u64(_target_block);
+            let input = BytesTrait::new_empty()
+                .encode_packed(latest_block)
+                .encode_packed(latest_header)
+                .encode_packed(_target_block);
 
-            let mut entry_calldata = BytesTrait::new_empty();
-            entry_calldata.append_felt252(selector!("commit_header_range"));
-            entry_calldata.append_u64(_target_block);
+            let entry_calldata = BytesTrait::new_empty()
+                .encode_packed(selector!("commit_header_range"))
+                .encode_packed(_target_block);
 
             ISuccinctGatewayDispatcher { contract_address: self.gateway.read() }
                 .request_call(
@@ -278,10 +279,10 @@ mod blobstreamx {
                 TendermintXErrors::TargetBlockNotInRange
             );
 
-            let mut input = BytesTrait::new_empty();
-            input.append_u64(latest_block);
-            input.append_u256(trusted_header);
-            input.append_u64(_target_block);
+            let input = BytesTrait::new_empty()
+                .encode_packed(latest_block)
+                .encode_packed(trusted_header)
+                .encode_packed(_target_block);
 
             // Get the output of the header_range proof from the gateway.
             let (target_header, data_commitment) = ISuccinctGatewayDispatcher {
@@ -314,13 +315,13 @@ mod blobstreamx {
             let latest_header = self.block_height_to_header_hash.read(latest_block);
             assert(latest_header != 0, TendermintXErrors::LatestHeaderNotFound);
 
-            let mut input = BytesTrait::new_empty();
-            input.append_u64(latest_block);
-            input.append_u256(latest_header);
+            let input = BytesTrait::new_empty()
+                .encode_packed(latest_block)
+                .encode_packed(latest_header);
 
-            let mut entry_calldata = BytesTrait::new_empty();
-            entry_calldata.append_felt252(selector!("commit_next_header"));
-            entry_calldata.append_u64(latest_block);
+            let entry_calldata = BytesTrait::new_empty()
+                .encode_packed(selector!("commit_next_header"))
+                .encode_packed(latest_block);
 
             ISuccinctGatewayDispatcher { contract_address: self.gateway.read() }
                 .request_call(
@@ -355,9 +356,9 @@ mod blobstreamx {
             let next_block = _trusted_block + 1;
             assert(next_block > self.get_latest_block(), TendermintXErrors::TargetBlockNotInRange);
 
-            let mut input = BytesTrait::new_empty();
-            input.append_u64(_trusted_block);
-            input.append_u256(trusted_header);
+            let input = BytesTrait::new_empty()
+                .encode_packed(_trusted_block)
+                .encode_packed(trusted_header);
 
             // Get the output of the next_header proof from the gateway.
             let (next_header, data_commitment) = ISuccinctGatewayDispatcher {

src/tests/test_blobstreamx.cairo

@@ -1,4 +1,5 @@
 use alexandria_bytes::{Bytes, BytesTrait};
+use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
 use blobstream_sn::blobstreamx::blobstreamx;
 use blobstream_sn::interfaces::{
     IBlobstreamXDispatcher, IBlobstreamXDispatcherTrait, Validator, ITendermintXDispatcher,
@@ -87,14 +88,14 @@ fn blobstreamx_fulfill_commit_header_range() {
     let gateway = get_gateway_contract(bsx.contract_address);
 
     // test data: https://sepolia.etherscan.io/tx/0x38ff4174e1e2c56d26f1f54e564fe282a662cff8335b3cd368e9a29004cee04d#eventlog
-    let mut input = BytesTrait::new_empty();
-    input.append_u64(TEST_START_BLOCK);
-    input.append_u256(TEST_HEADER);
-    input.append_u64(TEST_END_BLOCK);
-
-    let mut output = BytesTrait::new_empty();
-    output.append_u256(0x94a3afe8ce56375bedcb401c07a38a93a6b9d47461a01b6a410d5a958ca9bc7a);
-    output.append_u256(0xAAA0E18EB3689B8D88BE03EA19589E3565DB343F6509C8601DB6AFA01255A488);
+    let input = BytesTrait::new_empty()
+        .encode_packed(TEST_START_BLOCK)
+        .encode_packed(TEST_HEADER)
+        .encode_packed(TEST_END_BLOCK);
+
+    let output = BytesTrait::new_empty()
+        .encode_packed(0x94a3afe8ce56375bedcb401c07a38a93a6b9d47461a01b6a410d5a958ca9bc7a_u256)
+        .encode_packed(0xAAA0E18EB3689B8D88BE03EA19589E3565DB343F6509C8601DB6AFA01255A488_u256);
 
     gateway
         .fulfill_call(

src/tree/binary/hasher.cairo

@@ -1,17 +1,17 @@
 use alexandria_bytes::{Bytes, BytesTrait};
+use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
 use blobstream_sn::tree::consts::{LEAF_PREFIX, NODE_PREFIX};
 
 fn node_digest(left: u256, right: u256) -> u256 {
-    let mut bytes = BytesTrait::new_empty();
-    bytes.append_u8(NODE_PREFIX);
-    bytes.append_u256(left);
-    bytes.append_u256(right);
+    let bytes = BytesTrait::new_empty()
+        .encode_packed(NODE_PREFIX)
+        .encode_packed(left)
+        .encode_packed(right);
     bytes.sha256()
 }
 
 fn leaf_digest(data: @Bytes) -> u256 {
-    let mut bytes = BytesTrait::new_empty();
-    bytes.append_u8(LEAF_PREFIX);
+    let mut bytes = BytesTrait::new_empty().encode_packed(LEAF_PREFIX);
     bytes.concat(data);
     bytes.sha256()
 }

src/tree/binary/tests/test_hasher.cairo

@@ -1,4 +1,5 @@
 use alexandria_bytes::BytesTrait;
+use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
 use blobstream_sn::tree::binary::hasher::{leaf_digest, node_digest};
 
 #[test]
@@ -12,8 +13,7 @@ fn leaf_digest_empty_test() {
 #[test]
 fn leaf_digest_test() {
     let exp: u256 = 0x48c90c8ae24688d6bef5d48a30c2cc8b6754335a8db21793cc0a8e3bed321729;
-    let mut data = BytesTrait::new_empty();
-    data.append_u32(0xdeadbeef);
+    let data = BytesTrait::new_empty().encode_packed(0xdeadbeef_u32);
     let digest = leaf_digest(@data);
     assert_eq!(digest, exp, "leaf digest");
 }

src/tree/binary/tests/test_merkle_proof.cairo

@@ -1,4 +1,5 @@
 use alexandria_bytes::BytesTrait;
+use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
 use blobstream_sn::tree::binary::merkle_proof::BinaryMerkleProof;
 use blobstream_sn::tree::binary::merkle_tree::ErrorCodes;
 use blobstream_sn::tree::binary::merkle_tree;
@@ -35,8 +36,7 @@ fn verify_one_leaf_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 1;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u32(0xdeadbeef);
+    let data = BytesTrait::new_empty().encode_packed(0xdeadbeef_u32);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify one leaf test failed with error");
     assert!(is_valid, "verify one leaf test invalid");
@@ -49,8 +49,7 @@ fn verify_one_leaf_01_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 1;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify one leaf 01 test failed with error");
     assert!(is_valid, "verify one leaf 01 test invalid");
@@ -67,8 +66,7 @@ fn verify_leaf_one_of_eight_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify leaf one of eight test failed with error");
     assert!(is_valid, "verify leaf one of eight test invalid");
@@ -85,8 +83,7 @@ fn verify_leaf_two_of_eight_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x02);
+    let data = BytesTrait::new_empty().encode_packed(0x02_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify leaf two of eight test failed with error");
     assert!(is_valid, "verify leaf two of eight test invalid");
@@ -103,8 +100,7 @@ fn verify_leaf_three_of_eight_test() {
     let key: u256 = 2;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x03);
+    let data = BytesTrait::new_empty().encode_packed(0x03_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify leaf three of eight test failed with error");
     assert!(is_valid, "verify leaf three of eight test invalid");
@@ -121,8 +117,7 @@ fn verify_leaf_seven_of_eight_test() {
     let key: u256 = 6;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x07);
+    let data = BytesTrait::new_empty().encode_packed(0x07_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify leaf seven of eight test failed with error");
     assert!(is_valid, "verify leaf seven of eight test invalid");
@@ -139,8 +134,7 @@ fn verify_leaf_eight_of_eight_test() {
     let key: u256 = 7;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x08);
+    let data = BytesTrait::new_empty().encode_packed(0x08_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify leaf eight of eight test failed with error");
     assert!(is_valid, "verify leaf eight of eight test invalid");
@@ -158,8 +152,7 @@ fn verify_proof_of_five_leaves_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(
         error_code == ErrorCodes::NoError, "verify proof of five leaves test failed with error"
@@ -180,8 +173,7 @@ fn verify_invalid_proof_root_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify invalid proof root test failed with error");
     assert_eq!(is_valid, false, "verify invalid proof root test should be invalid");
@@ -200,8 +192,7 @@ fn verify_invalid_proof_key_test() {
     let key: u256 = 2;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify invalid proof key test failed with error");
     assert_eq!(is_valid, false, "verify invalid proof key test should be invalid");
@@ -220,8 +211,7 @@ fn verify_invalid_proof_number_of_leaves_test() {
     // correct num_leaves: u256 = 5;
     let num_leaves: u256 = 200;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(
         error_code == ErrorCodes::InvalidNumberOfSideNodes,
@@ -243,8 +233,7 @@ fn verify_invalid_proof_side_nodes_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(
         error_code == ErrorCodes::NoError, "verify invalid proof side nodes test failed with error"
@@ -264,9 +253,8 @@ fn verify_invalid_proof_data_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    // correct data.append_u8(0x01);
-    data.append_u32(0x012345);
+    let data = BytesTrait::new_empty() // correct .encode_packed(0x01_u8);
+        .encode_packed(0x012345_u32);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify invalid proof data test failed with error");
     assert_eq!(is_valid, false, "verify invalid proof data test should be invalid");
@@ -279,8 +267,7 @@ fn same_key_and_leaves_number_test() {
     let key: u256 = 3;
     let num_leaves: u256 = 3;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(
         error_code == ErrorCodes::InvalidNumberOfSideNodes,
@@ -296,8 +283,7 @@ fn consecutive_key_and_number_of_leaves_test() {
     let key: u256 = 6;
     let num_leaves: u256 = 7;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(
         error_code == ErrorCodes::InvalidNumberOfSideNodes,
@@ -317,8 +303,7 @@ fn key_not_in_tree_test() {
     let key: u256 = 9;
     let num_leaves: u256 = 8;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x01);
+    let data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::KeyNotInTree, "key not in tree test failed with error");
     assert_eq!(is_valid, false, "key not in tree test failed");

src/tree/namespace/hasher.cairo

@@ -1,4 +1,5 @@
 use alexandria_bytes::{Bytes, BytesTrait};
+use alexandria_encoding::sol_abi::{SolBytesTrait, SolAbiEncodeTrait};
 use alexandria_math::U256BitShift;
 use blobstream_sn::tree::consts::{LEAF_PREFIX, NODE_PREFIX, parity_share_namespace};
 use blobstream_sn::tree::namespace::Namespace;
@@ -7,10 +8,10 @@ use blobstream_sn::tree::namespace::merkle_tree::{
 };
 
 fn leaf_digest(namespace: Namespace, data: @Bytes) -> NamespaceNode {
-    let mut bytes = BytesTrait::new_empty();
-    bytes.append_u8(LEAF_PREFIX);
-    bytes.append_u8(namespace.version);
-    append_bytes28(ref bytes, namespace.id);
+    let mut bytes = BytesTrait::new_empty()
+        .encode_packed(LEAF_PREFIX)
+        .encode_packed(namespace.version)
+        .encode_packed(SolBytesTrait::bytes28(namespace.id));
     bytes.concat(data);
     return NamespaceNode { min: namespace, max: namespace, digest: bytes.sha256() };
 }
@@ -38,18 +39,18 @@ fn node_digest(left: NamespaceNode, right: NamespaceNode) -> NamespaceNode {
         max = left.max;
     }
 
-    let mut bytes = BytesTrait::new_empty();
-    bytes.append_u8(NODE_PREFIX);
-    bytes.append_u8(left.min.version);
-    append_bytes28(ref bytes, left.min.id);
-    bytes.append_u8(left.max.version);
-    append_bytes28(ref bytes, left.max.id);
-    bytes.append_u256(left.digest);
-    bytes.append_u8(right.min.version);
-    append_bytes28(ref bytes, right.min.id);
-    bytes.append_u8(right.max.version);
-    append_bytes28(ref bytes, right.max.id);
-    bytes.append_u256(right.digest);
+    let bytes = BytesTrait::new_empty()
+        .encode_packed(NODE_PREFIX)
+        .encode_packed(left.min.version)
+        .encode_packed(SolBytesTrait::bytes28(left.min.id))
+        .encode_packed(left.max.version)
+        .encode_packed(SolBytesTrait::bytes28(left.max.id))
+        .encode_packed(left.digest)
+        .encode_packed(right.min.version)
+        .encode_packed(SolBytesTrait::bytes28(right.min.id))
+        .encode_packed(right.max.version)
+        .encode_packed(SolBytesTrait::bytes28(right.max.id))
+        .encode_packed(right.digest);
 
     return NamespaceNode { min: min, max: max, digest: bytes.sha256() };
 }

src/tree/namespace/tests/test_hasher.cairo

@@ -1,4 +1,5 @@
 use alexandria_bytes::BytesTrait;
+use alexandria_encoding::sol_abi::{SolAbiEncodeTrait};
 use blobstream_sn::tree::consts::{parity_share_namespace};
 use blobstream_sn::tree::namespace::Namespace;
 use blobstream_sn::tree::namespace::hasher;
@@ -37,8 +38,7 @@ fn test_leaf_digest_some() {
         digest: 0x3624c7f7169cb5bbd0d010b851ebd0edca10b2a1b126f5fb1a6d5e0d98356e63
     };
 
-    let mut data = BytesTrait::new_empty();
-    data.append_u8(0x69);
+    let data = BytesTrait::new_empty().encode_packed(0x69_u8);
 
     let node = hasher::leaf_digest(nid, @data);
     assert!(node.digest == expected.digest, "Not equal to expected digest");