Bump crate dependencies (#1494)

Update all dependencies that can be updated.

Signed-off-by: Sean Young <sean@mess.org>

Cargo.toml

@@ -35,7 +35,7 @@ contract-metadata = "3.0"
 semver = { version = "1.0", features = ["serde"] }
 tempfile = "3.4"
 libc = { version = "0.2", optional = true }
-tower-lsp = "0.19"
+tower-lsp = "0.20"
 tokio = { version = "1.27", features = ["rt", "io-std", "macros"] }
 base58 = "0.2.0"
 sha2 = "0.10"
@@ -58,8 +58,8 @@ ink_env = "4.2.0"
 ink_metadata = "4.2.0"
 scale-info = "2.4"
 petgraph = "0.6.3"
-wasmparser = "0.107.0"
-wasm-encoder = "0.29"
+wasmparser = "0.110.0"
+wasm-encoder = "0.31"
 toml = "0.7"
 wasm-opt = { version = "0.112.0", optional = true }
 contract-build = { version = "3.0.1", optional = true }
@@ -68,15 +68,13 @@ normalize-path = "0.2.1"
 
 [dev-dependencies]
 num-derive = "0.4"
-wasmi = "0.30"
-# rand version 0.7 is needed for ed25519_dalek::keypair::generate, used in solana_tests/signature_verify.rs
-rand_07 = { package = "rand", version = "0.7" }
+wasmi = "0.31"
 # solana_rbpf makes api changes in patch versions
-solana_rbpf = "=0.5.0"
+solana_rbpf = "=0.6.0"
 byteorder = "1.4"
 assert_cmd = "2.0"
 bincode = "1.3"
-ed25519-dalek = "1.0"
+ed25519-dalek = { version = "2", features = ["rand_core"] }
 path-slash = "0.2"
 pretty_assertions = "1.3"
 byte-slice-cast = "1.2"

src/bin/languageserver/mod.rs

@@ -1812,7 +1812,7 @@ impl LanguageServer for SolangServer {
 
         let path = uri.to_file_path().map_err(|_| Error {
             code: ErrorCode::InvalidRequest,
-            message: format!("Received invalid URI: {uri}"),
+            message: format!("Received invalid URI: {uri}").into(),
             data: None,
         })?;
         let files = self.files.lock().await;

tests/polkadot_tests/variables.rs

@@ -53,7 +53,7 @@ fn global_constants() {
 #[test]
 fn ensure_unread_storage_vars_write() {
     let mut runtime = build_solidity(
-        r##"import "polkadot";
+        r#"import "polkadot";
         contract C {
             uint8 foo;
             function c(uint8[32] code) public payable {
@@ -61,7 +61,7 @@ fn ensure_unread_storage_vars_write() {
                 require(set_code_hash(code) == 0);
             }
         }
-        contract A { uint8 public foo; }"##,
+        contract A { uint8 public foo; }"#,
     );
 
     runtime.function("c", runtime.contracts()[1].code.hash.encode());
@@ -81,7 +81,7 @@ fn ext_fn_call_is_reading_variable() {
                 return func(arg);
             }
         }
-        
+
         contract A {
             function a(uint32 arg) public pure returns (uint32) {
                 return arg;

tests/solana.rs

@@ -12,7 +12,7 @@ use sha2::{Digest, Sha256};
 use solana_rbpf::{
     aligned_memory::AlignedMemory,
     ebpf,
-    elf::Executable,
+    elf::{Executable, SBPFVersion},
     error::EbpfError,
     memory_region::{AccessType, MemoryMapping, MemoryRegion},
     verifier::{RequisiteVerifier, TautologyVerifier},
@@ -1371,13 +1371,13 @@ impl VirtualMachine {
         let mut heap = vec![0_u8; DEFAULT_HEAP_SIZE];
 
         let program = &self.stack[0];
-
-        let mut loader = BuiltinProgram::new_loader(Config {
-            static_syscalls: false,
+        let config = Config {
+            enable_sbpf_v1: true,
             enable_symbol_and_section_labels: false,
-            dynamic_stack_frames: false,
             ..Config::default()
-        });
+        };
+
+        let mut loader = BuiltinProgram::new_loader(config);
 
         loader.register_function(b"sol_panic_", sol_panic_).unwrap();
 
@@ -1455,11 +1455,18 @@ impl VirtualMachine {
             MemoryRegion::new_writable(stack.as_slice_mut(), ebpf::MM_STACK_START),
         ];
 
-        let memory_mapping = MemoryMapping::new(parameter_region, &config).unwrap();
+        let memory_mapping =
+            MemoryMapping::new(parameter_region, &config, &SBPFVersion::V1).unwrap();
 
-        let mut vm = EbpfVm::new(&verified_executable, &mut context, memory_mapping, 4196);
+        let mut vm = EbpfVm::new(
+            &config,
+            &SBPFVersion::V1,
+            &mut context,
+            memory_mapping,
+            4196,
+        );
 
-        let (_, res) = vm.execute_program(true);
+        let (_, res) = vm.execute_program(&verified_executable, true);
 
         deserialize_parameters(&parameter_bytes, &refs, &mut self.account_data);
 

tests/solana_tests/signature_verify.rs

@@ -2,14 +2,15 @@
 
 use crate::{build_solidity, Account, AccountState, BorshToken};
 use base58::FromBase58;
-use ed25519_dalek::{Keypair, Signature, Signer};
+use ed25519_dalek::{Signature, Signer, SigningKey};
+use rand::rngs::OsRng;
 use serde_derive::Serialize;
 use std::convert::TryInto;
 use std::mem::size_of;
 
 #[derive(Serialize)]
 #[repr(C)]
-struct instructions {
+struct Instructions {
     num_instructions: u16,
     instruction_offset: u16,
     num_accounts: u16,
@@ -56,8 +57,8 @@ fn verify() {
     vm.account_data
         .insert(instructions_account, AccountState::default());
 
-    let mut csprng = rand_07::thread_rng();
-    let keypair: Keypair = Keypair::generate(&mut csprng);
+    let mut csprng = OsRng;
+    let keypair: SigningKey = SigningKey::generate(&mut csprng);
 
     let message: &[u8] =
         b"This is a test of the ed25519 sig check for the ed25519 signature check program";
@@ -66,14 +67,17 @@ fn verify() {
 
     let signature_bs = signature.to_bytes().to_vec();
 
-    println!("T: PUB: {}", hex::encode(keypair.public.to_bytes()));
+    println!(
+        "T: PUB: {}",
+        hex::encode(keypair.verifying_key().to_bytes())
+    );
     println!("T: SIG: {}", hex::encode(&signature_bs));
     println!("T: MES: {}", hex::encode(message));
 
     let returns = vm
         .function("verify")
         .arguments(&[
-            BorshToken::Address(keypair.public.to_bytes()),
+            BorshToken::Address(keypair.verifying_key().to_bytes()),
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs.clone()),
         ])
@@ -91,7 +95,8 @@ fn verify() {
         .unwrap()
         .try_into()
         .unwrap();
-    let instructions = encode_instructions(&keypair.public.to_bytes(), &signature_bs, message);
+    let instructions =
+        encode_instructions(&keypair.verifying_key().to_bytes(), &signature_bs, message);
 
     vm.account_data.insert(
         instructions_account,
@@ -107,7 +112,7 @@ fn verify() {
     let returns = vm
         .function("verify")
         .arguments(&[
-            BorshToken::Address(keypair.public.to_bytes()),
+            BorshToken::Address(keypair.verifying_key().to_bytes()),
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs.clone()),
         ])
@@ -126,7 +131,11 @@ fn verify() {
     let mut signature_copy = signature_bs.clone();
     signature_copy[2] ^= 0x80;
 
-    let instructions = encode_instructions(&keypair.public.to_bytes(), &signature_copy, message);
+    let instructions = encode_instructions(
+        &keypair.verifying_key().to_bytes(),
+        &signature_copy,
+        message,
+    );
 
     vm.account_data.insert(
         instructions_account,
@@ -140,7 +149,7 @@ fn verify() {
     let returns = vm
         .function("verify")
         .arguments(&[
-            BorshToken::Address(keypair.public.to_bytes()),
+            BorshToken::Address(keypair.verifying_key().to_bytes()),
             BorshToken::Bytes(message.to_vec()),
             BorshToken::Bytes(signature_bs),
         ])
@@ -174,7 +183,7 @@ fn encode_instructions(public_key: &[u8], signature: &[u8], message: &[u8]) -> V
     ed25519_instruction.extend_from_slice(public_key);
     ed25519_instruction.extend_from_slice(message);
 
-    let instr = instructions {
+    let instr = Instructions {
         num_instructions: 1,
         instruction_offset: 4,
         num_accounts: 0,