Merge pull request #14 from rustopian/master

sync

Author: rustopian

.github/actions/setup/action.yml

@@ -28,6 +28,9 @@ inputs:
   miri:
     description: Install Miri if `true`. Defaults to `false`.
     required: false
+  rust-src:
+    description: Install rust-src if `true`. Defaults to `false`.
+    required: false
   llvm-tools-preview:
     description: Install llvm-tools-preview if `true`. Defaults to `false`.
     required: false
@@ -118,6 +121,13 @@ runs:
         toolchain: ${{ env.RUST_NIGHTLY }}
         components: llvm-tools-preview
 
+    - name: Install rust-src
+      if: ${{ inputs.rust-src == 'true' }}
+      uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ env.RUST_NIGHTLY }}
+        components: rust-src
+
     - name: Install Agave build dependencies
       if: ${{ inputs.agave == 'true' }}
       shell: bash

.github/workflows/main.yml

@@ -551,3 +551,22 @@ jobs:
 
       - name: Run benches
         run: ./scripts/test-bench.sh
+
+  check-no-std:
+    name: Check no_std build
+    runs-on: ubuntu-latest
+    needs: [sanity]
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Environment
+        uses: ./.github/actions/setup
+        with:
+          nightly-toolchain: true
+          rust-src: true
+          cargo-cache-key: cargo-nightly-no-std
+          cargo-cache-fallback-key: cargo-nightly
+
+      - name: Run check
+        run: ./scripts/check-no-std.sh

Cargo.lock

@@ -712,6 +712,22 @@ impl AccountSharedData {
     pub fn serialize_data<T: serde::Serialize>(&mut self, state: &T) -> Result<(), bincode::Error> {
         shared_serialize_data(self, state)
     }
+
+    pub fn create_from_existing_shared_data(
+        lamports: u64,
+        data: Arc<Vec<u8>>,
+        owner: Pubkey,
+        executable: bool,
+        rent_epoch: Epoch,
+    ) -> AccountSharedData {
+        AccountSharedData {
+            lamports,
+            data,
+            owner,
+            executable,
+            rent_epoch,
+        }
+    }
 }
 
 pub type InheritableAccountFields = (u64, Epoch);

account/src/lib.rs

@@ -1,5 +1,5 @@
 //! Definitions of commitment levels.
-
+#![no_std]
 use core::{fmt, str::FromStr};
 
 #[cfg_attr(
@@ -110,8 +110,8 @@ impl FromStr for CommitmentLevel {
     }
 }
 
-impl std::fmt::Display for CommitmentLevel {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Display for CommitmentLevel {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let s = match self {
             CommitmentLevel::Processed => "processed",
             CommitmentLevel::Confirmed => "confirmed",

commitment-config/src/lib.rs

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -eo pipefail
+
+here="$(dirname "$0")"
+src_root="$(readlink -f "${here}/..")"
+
+cd "${src_root}"
+
+no_std_crates=(
+  -p solana-address
+  -p solana-clock
+  -p solana-commitment-config
+  -p solana-define-syscall
+  -p solana-fee-calculator
+  -p solana-program-error
+  -p solana-program-memory
+  -p solana-rent
+  -p solana-sanitize
+  -p solana-signature
+)
+# Use the upstream BPF target, which doesn't support std, to make sure that our
+# no_std support really works.
+target="bpfel-unknown-none"
+
+./cargo nightly check -Zbuild-std=core \
+  "--target=$target" \
+  --no-default-features \
+  "${no_std_crates[@]}"

scripts/check-no-std.sh

@@ -24,6 +24,7 @@ solana-hash = { workspace = true }
 solana-instruction = { workspace = true, features = ["std"] }
 solana-keypair = { workspace = true }
 solana-message = { workspace = true }
+solana-packet = { workspace = true }
 solana-signature = { workspace = true }
 solana-signer = { workspace = true }
 solana-transaction = { workspace = true, features = ["bincode", "verify"] }

sdk-wasm-js/Cargo.toml

@@ -3,6 +3,7 @@
 use {
     crate::display_to_jsvalue,
     js_sys::{Array, Uint8Array},
+    solana_address::{ADDRESS_BYTES, MAX_SEEDS, MAX_SEED_LEN},
     wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue},
 };
 
@@ -15,20 +16,33 @@ pub struct Address {
 crate::conversion::impl_inner_conversion!(Address, solana_address::Address);
 
 fn js_value_to_seeds_vec(array_of_uint8_arrays: &[JsValue]) -> Result<Vec<Vec<u8>>, JsValue> {
-    let vec_vec_u8 = array_of_uint8_arrays
+    if array_of_uint8_arrays.len() > MAX_SEEDS {
+        return Err(JsValue::from(std::format!(
+            "Too many seeds: {} > {}",
+            array_of_uint8_arrays.len(),
+            MAX_SEEDS
+        )));
+    }
+
+    array_of_uint8_arrays
         .iter()
-        .filter_map(|u8_array| {
-            u8_array
+        .enumerate()
+        .map(|(i, u8_array_js)| {
+            let u8_array = u8_array_js
                 .dyn_ref::<Uint8Array>()
-                .map(|u8_array| u8_array.to_vec())
-        })
-        .collect::<Vec<_>>();
+                .ok_or_else(|| JsValue::from(std::format!("Invalid seed type at index {}", i)))?;
+            if u8_array.length() as usize > MAX_SEED_LEN {
+                return Err(JsValue::from(std::format!(
+                    "Seed {} too long: {} > {}",
+                    i,
+                    u8_array.length(),
+                    MAX_SEED_LEN
+                )));
+            }
 
-    if vec_vec_u8.len() != array_of_uint8_arrays.len() {
-        Err("Invalid Array of Uint8Arrays".into())
-    } else {
-        Ok(vec_vec_u8)
-    }
+            Ok(u8_array.to_vec())
+        })
+        .collect::<Result<Vec<_>, _>>()
 }
 
 #[allow(non_snake_case)]
@@ -45,26 +59,40 @@ impl Address {
                 .map(Into::into)
                 .map_err(display_to_jsvalue)
         } else if let Some(uint8_array) = value.dyn_ref::<Uint8Array>() {
-            solana_address::Address::try_from(uint8_array.to_vec())
-                .map(Into::into)
-                .map_err(|err| JsValue::from(std::format!("Invalid Uint8Array address: {err:?}")))
+            if uint8_array.length() as usize != ADDRESS_BYTES {
+                return Err(std::format!(
+                    "Invalid Uint8Array length: expected {}, got {}",
+                    ADDRESS_BYTES,
+                    uint8_array.length()
+                )
+                .into());
+            }
+            let mut bytes = [0u8; ADDRESS_BYTES];
+            uint8_array.copy_to(&mut bytes);
+            Ok(solana_address::Address::new_from_array(bytes).into())
         } else if let Some(array) = value.dyn_ref::<Array>() {
-            let mut bytes = std::vec![];
+            if array.length() as usize != ADDRESS_BYTES {
+                return Err(std::format!(
+                    "Invalid Array length: expected {}, got {}",
+                    ADDRESS_BYTES,
+                    array.length()
+                )
+                .into());
+            }
+            let mut bytes = [0u8; ADDRESS_BYTES];
             let iterator = js_sys::try_iter(&array.values())?.expect("array to be iterable");
-            for x in iterator {
+            for (i, x) in iterator.enumerate() {
                 let x = x?;
 
                 if let Some(n) = x.as_f64() {
                     if n >= 0. && n <= 255. {
-                        bytes.push(n as u8);
+                        bytes[i] = n as u8;
                         continue;
                     }
                 }
                 return Err(std::format!("Invalid array argument: {:?}", x).into());
             }
-            solana_address::Address::try_from(bytes)
-                .map(Into::into)
-                .map_err(|err| JsValue::from(std::format!("Invalid Array address: {err:?}")))
+            Ok(solana_address::Address::new_from_array(bytes).into())
         } else if value.is_undefined() {
             Ok(solana_address::Address::default().into())
         } else {

sdk-wasm-js/src/address.rs

@@ -1,7 +1,8 @@
 //! Wrapper over `solana_hash::Hash` with wasm-bindgen
 use {
     js_sys::{Array, Uint8Array},
-    std::{boxed::Box, format, string::String, vec},
+    solana_hash::HASH_BYTES,
+    std::{boxed::Box, format, string::String},
     wasm_bindgen::{prelude::*, JsCast},
 };
 
@@ -27,28 +28,41 @@ impl Hash {
                 .map(Into::into)
                 .map_err(|x| JsValue::from(x.to_string()))
         } else if let Some(uint8_array) = value.dyn_ref::<Uint8Array>() {
-            <[u8; solana_hash::HASH_BYTES]>::try_from(uint8_array.to_vec())
-                .map(solana_hash::Hash::new_from_array)
-                .map(Into::into)
-                .map_err(|err| format!("Invalid Hash value: {err:?}").into())
+            if uint8_array.length() as usize != HASH_BYTES {
+                return Err(format!(
+                    "Invalid Uint8Array length: expected {}, got {}",
+                    HASH_BYTES,
+                    uint8_array.length()
+                )
+                .into());
+            }
+            let mut bytes = [0u8; HASH_BYTES];
+            uint8_array.copy_to(&mut bytes);
+            Ok(solana_hash::Hash::new_from_array(bytes).into())
         } else if let Some(array) = value.dyn_ref::<Array>() {
-            let mut bytes = vec![];
+            if array.length() as usize != HASH_BYTES {
+                return Err(format!(
+                    "Invalid Array length: expected {}, got {}",
+                    HASH_BYTES,
+                    array.length()
+                )
+                .into());
+            }
+
+            let mut bytes = [0u8; HASH_BYTES];
             let iterator = js_sys::try_iter(&array.values())?.expect("array to be iterable");
-            for x in iterator {
+            for (i, x) in iterator.enumerate() {
                 let x = x?;
 
                 if let Some(n) = x.as_f64() {
                     if n >= 0. && n <= 255. {
-                        bytes.push(n as u8);
+                        bytes[i] = n as u8;
                         continue;
                     }
                 }
                 return Err(format!("Invalid array argument: {:?}", x).into());
             }
-            <[u8; solana_hash::HASH_BYTES]>::try_from(bytes)
-                .map(solana_hash::Hash::new_from_array)
-                .map(Into::into)
-                .map_err(|err| format!("Invalid Hash value: {err:?}").into())
+            Ok(solana_hash::Hash::new_from_array(bytes).into())
         } else if value.is_undefined() {
             Ok(solana_hash::Hash::default().into())
         } else {

sdk-wasm-js/src/hash.rs

@@ -3,7 +3,12 @@
 //! (ref: https://github.com/rustwasm/wasm-bindgen/issues/111)
 #![allow(non_snake_case)]
 
-use {crate::address::Address, wasm_bindgen::prelude::*};
+use {
+    crate::address::Address, js_sys::Uint8Array, solana_packet::PACKET_DATA_SIZE,
+    wasm_bindgen::prelude::*,
+};
+
+const MAX_INSTRUCTION_DATA_LEN: usize = PACKET_DATA_SIZE;
 
 /// wasm-bindgen version of the Instruction struct.
 /// This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
@@ -25,8 +30,18 @@ impl Instruction {
             .into()
     }
 
-    pub fn setData(&mut self, data: &[u8]) {
+    pub fn setData(&mut self, data: Uint8Array) -> Result<(), JsValue> {
+        if data.length() as usize > MAX_INSTRUCTION_DATA_LEN {
+            return Err(std::format!(
+                "Instruction data too large: {} > {}",
+                data.length(),
+                MAX_INSTRUCTION_DATA_LEN
+            )
+            .into());
+        }
+
         self.inner.data = data.to_vec();
+        Ok(())
     }
 
     pub fn addAccount(&mut self, account_meta: AccountMeta) {