Merge pull request #44 from skalenetwork/bug/36-dont-use-buffer

Bug/36 dont use buffer

Author: olehnikolaiev

.github/workflows/test.yml

@@ -32,7 +32,7 @@ jobs:
 
       - name: Run sgx container
         run: |
-          export SGX_WALLET_TAG=1.10.1-develop.3
+          export SGX_WALLET_TAG=1.10.2-develop.6
           echo "SGX_WALLET_TAG=$SGX_WALLET_TAG" >> $GITHUB_ENV
           bash ./scripts/run_sgx_container.sh $SGX_WALLET_TAG
           echo "Waiting for SGX wallet to be ready..."
@@ -59,7 +59,7 @@ jobs:
 
       - name: Run skaled container
         run: |
-          export SKALED_RELEASE=5.1.0-develop.7-bite2
+          export SKALED_RELEASE=5.1.0-develop.38-bite
           echo "SKALED_RELEASE=$SKALED_RELEASE" >> $GITHUB_ENV
         shell: bash
 

examples/confidential-token-demo/src/encryption.js

@@ -1,5 +1,5 @@
 import { ethers } from 'ethers';
-import { BITE } from '@skalenetwork/bite';
+import { BITE, bytesToHex, concatBytes, hexToBytes } from '@skalenetwork/bite';
 import crypto from 'crypto';
 
 export async function encryptTokenTransfer(rpcUrl, provider, tokenAddress, recipient, amount) {
@@ -39,16 +39,16 @@ export function decryptBalance(secretKey, encryptedDataHex) {
     const cleanSecretKey = secretKey.startsWith('0x') ? secretKey.slice(2) : secretKey;
     const cleanEncryptedData = encryptedDataHex.startsWith('0x') ? encryptedDataHex.slice(2) : encryptedDataHex;
 
-    const encryptedDataBuffer = Buffer.from(cleanEncryptedData, 'hex');
+    const encryptedDataBytes = hexToBytes(cleanEncryptedData);
 
     // Extract parts
-    const iv = encryptedDataBuffer.subarray(0, 16);
-    const ephemeralPublicKey = encryptedDataBuffer.subarray(16, 16 + 33);
-    const ciphertext = encryptedDataBuffer.subarray(16 + 33);
+    const iv = encryptedDataBytes.subarray(0, 16);
+    const ephemeralPublicKey = encryptedDataBytes.subarray(16, 16 + 33);
+    const ciphertext = encryptedDataBytes.subarray(16 + 33);
 
     // Derive Shared Secret
     const ecdh = crypto.createECDH('secp256k1');
-    ecdh.setPrivateKey(Buffer.from(cleanSecretKey, 'hex'));
+    ecdh.setPrivateKey(hexToBytes(cleanSecretKey));
 
     // computeSecret requires the other party's public key
     const sharedSecret = ecdh.computeSecret(ephemeralPublicKey);
@@ -61,17 +61,17 @@ export function decryptBalance(secretKey, encryptedDataHex) {
     // Decrypt: AES-256-CBC with PKCS7 unpadding (default for createDecipheriv)
     const decipher = crypto.createDecipheriv('aes-256-cbc', encryptionKey, iv);
     let decrypted = decipher.update(ciphertext);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    decrypted = concatBytes(decrypted, decipher.final());
 
     // If the plaintext was stored as a *textual* hex string (e.g. "0x..."), UTF-8 decoding is correct.
     // If it was stored as raw bytes, represent it as hex instead.
-    let decryptedString = decrypted.toString('utf8');
+    let decryptedString = new TextDecoder().decode(decrypted);
 
     const maybeHex = decryptedString.startsWith('0x') ? decryptedString.slice(2) : decryptedString;
     const looksLikeHex = /^[0-9a-fA-F]*$/.test(maybeHex) && maybeHex.length % 2 === 0;
 
     if (!looksLikeHex) {
-        decryptedString = `0x${decrypted.toString('hex')}`;
+        decryptedString = `0x${bytesToHex(decrypted)}`;
     }
 
     // Convert hex string to decimal if applicable

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skalenetwork/bite",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "TS Library to interact with BITE protocol",
   "homepage": "https://github.com/skalenetwork/bite.ts",
   "license": "LGPL-3.0-or-later",

scripts/endpoint_by_container/data_dir/config.json

@@ -372,6 +372,10 @@
             "flexibleDeploymentPatchTimestamp": 1721826000,
             "verifyBlsSyncPatchTimestamp": 1721829600,
             "externalGasPatchTimestamp": 1727712000,
+            "bite2PatchTimestamp": 1735689600,
+            "singleStateCommitPerBlockPatchTimestamp": 1735689600,
+            "contractCreationReadOnlyPatchTimestamp": 1735689600,
+            "currentBlockRandomPatchTimestamp": 1735689600,
             "emptyBlockIntervalMs": 1000
         }
     }

src/core/encrypt.ts

@@ -30,6 +30,7 @@ import { encode } from '@ethereumjs/rlp';
 import {logger} from "../utils/logger";
 import * as utils from '../utils/helper';
 import * as constants from '../utils/constants';
+import { bytesToHex, hexToBytes } from '../utils/bytes';
 
 
 export interface Transaction {
@@ -152,14 +153,14 @@ export async function encryptMessage(
             const encryptedRawMessage = await encryptRawMessage(data, publicKeyResponse.commonBLSPublicKey, sanitizedAADTE, sanitizedAADAES);
 
             // RLP encode epochID and encrypted message
-            const rlpEncodedResult = rlpEncodeMessageData([publicKeyResponse.epochId, Buffer.from(encryptedRawMessage, 'hex')]);
+            const rlpEncodedResult = rlpEncodeMessageData([publicKeyResponse.epochId, hexToBytes(encryptedRawMessage)]);
             return `0x${rlpEncodedResult}`;
         } else {
             const encryptedRawMessage = await encryptRawMessageDualKey(data, committees[0].commonBLSPublicKey,
                 committees[1].commonBLSPublicKey, sanitizedAADTE, sanitizedAADAES);
 
             // RLP encode epochID and encrypted message
-            const rlpEncodedResult = rlpEncodeMessageData([committees[0].epochId, Buffer.from(encryptedRawMessage, 'hex')]);
+            const rlpEncodedResult = rlpEncodeMessageData([committees[0].epochId, hexToBytes(encryptedRawMessage)]);
             return `0x${rlpEncodedResult}`;
         }
     } catch (error) {
@@ -188,7 +189,7 @@ export async function encryptMessageMockup(
         const epochId = 0;
 
         // RLP encode epochID and encrypted message
-        const rlpEncodedResult = rlpEncodeMessageData([epochId, Buffer.from(encryptedRawMessage, 'hex')]);
+        const rlpEncodedResult = rlpEncodeMessageData([epochId, hexToBytes(encryptedRawMessage)]);
         return `0x${rlpEncodedResult}`;
     } catch (error) {
         logger.error('Error encrypting message:', error);
@@ -234,15 +235,15 @@ function validateAndExtractTransactionFields(tx: Transaction): Transaction {
  */
 function rlpEncodeTransactionData(txTo: string, txData: string): string {
     try {
-        // Convert hex strings to Buffer for RLP encoding
-        const toBuffer = Buffer.from(txTo, 'hex');
-        const dataBuffer = Buffer.from(txData, 'hex');
+        // Convert hex strings to bytes for RLP encoding
+        const toBytes = hexToBytes(txTo);
+        const dataBytes = hexToBytes(txData);
 
         // RLP encode as array [txData, txTo]
-        const rlpEncoded = encode([dataBuffer, toBuffer]);
+        const rlpEncoded = encode([dataBytes, toBytes]);
 
         // Convert back to hex string without 0x prefix
-        return Buffer.from(rlpEncoded).toString('hex');
+        return bytesToHex(rlpEncoded);
     } catch (error) {
         logger.error('Error RLP encoding transaction data:', error);
         throw new Error('Failed to RLP encode transaction data');
@@ -251,16 +252,16 @@ function rlpEncodeTransactionData(txTo: string, txData: string): string {
 
 /**
  * RLP encodes array of epochId and encrypted message
- * @param {(number | Buffer | (number | Buffer)[])[]} data - Array of data to RLP encode
+ * @param {(number | Uint8Array | (number | Uint8Array)[])[]} data - Array of data to RLP encode
  * @returns {string} RLP encoded data as hex string (without 0x prefix)
  */
-function rlpEncodeMessageData(data: (number | Buffer | (number | Buffer)[])[]): string {
+function rlpEncodeMessageData(data: (number | Uint8Array | (number | Uint8Array)[])[]): string {
     try {
         // RLP encode the array
         const rlpEncoded = encode(data);
 
         // Convert back to hex string without 0x prefix
-        return Buffer.from(rlpEncoded).toString('hex');
+        return bytesToHex(rlpEncoded);
     } catch (error) {
         logger.error('Error RLP encoding message data:', error);
         throw new Error('Failed to RLP encode message data');

src/index.ts

@@ -22,4 +22,5 @@
  */
 
 export * from './core/bite';
-export { type Transaction } from './core/encrypt';
+export { type Transaction } from './core/encrypt';
+export { bytesToHex, concatBytes, hexToBytes } from './utils/bytes';

src/utils/bytes.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * SKALE bite.ts
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * @file bytes.ts
+ * @copyright SKALE Labs 2026-Present
+ */
+
+import { validateHexString } from './helper';
+
+export function hexToBytes(hex: string): Uint8Array {
+    const sanitizedHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    validateHexString(sanitizedHex);
+    const bytes = new Uint8Array(sanitizedHex.length / 2);
+
+    for (let i = 0; i < sanitizedHex.length; i += 2) {
+        bytes[i / 2] = parseInt(sanitizedHex.slice(i, i + 2), 16);
+    }
+
+    return bytes;
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
+    const totalLength = arrays.reduce((sum, array) => sum + array.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+
+    return result;
+}

tests/test_epoch_validation.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { BITE } = require('..');
+const { BITE, bytesToHex, hexToBytes } = require('..');
 const { encode } = require('@ethereumjs/rlp');
 const ethers = require('ethers');
 
@@ -63,19 +63,19 @@ async function createForgedTransaction(transaction, forgedEpochId, publicKey) {
         const txData = transaction.data.startsWith('0x') ? transaction.data.slice(2) : transaction.data;
 
         // RLP encode transaction data (same as in the real encrypt function)
-        const toBuffer = Buffer.from(txTo, 'hex');
-        const dataBuffer = Buffer.from(txData, 'hex');
-        const rlpEncodedTxData = encode([dataBuffer, toBuffer]);
-        const rlpEncodedTxHex = Buffer.from(rlpEncodedTxData).toString('hex');
+        const toBytes = hexToBytes(txTo);
+        const dataBytes = hexToBytes(txData);
+        const rlpEncodedTxData = encode([dataBytes, toBytes]);
+        const rlpEncodedTxHex = bytesToHex(rlpEncodedTxData);
 
         // Encrypt the RLP encoded transaction data using the same BLS key
         const encryptedRawMessage = await encryptRawMessage(rlpEncodedTxHex, publicKey);
 
         // RLP encode with forged epochId (same structure as real encrypt function)
-        const encryptedMessageBuffer = Buffer.from(encryptedRawMessage, 'hex');
-        const forgedRlpEncoded = encode([forgedEpochId, encryptedMessageBuffer]);
+        const encryptedMessageBytes = hexToBytes(encryptedRawMessage);
+        const forgedRlpEncoded = encode([forgedEpochId, encryptedMessageBytes]);
 
-        return '0x' + Buffer.from(forgedRlpEncoded).toString('hex');
+        return '0x' + bytesToHex(forgedRlpEncoded);
     } catch (error) {
         console.error('Error creating forged transaction:', error);
         throw error;