Merge branch 'main' into debug-assert-in-contract

Author: mootz12

soroban-sdk/src/crypto.rs

@@ -161,10 +161,10 @@ impl Crypto {
         &self,
         message_digest: &Hash<32>,
         signature: &BytesN<64>,
-        recorvery_id: u32,
+        recovery_id: u32,
     ) -> BytesN<65> {
         let env = self.env();
-        CryptoHazmat::new(env).secp256k1_recover(&message_digest.0, signature, recorvery_id)
+        CryptoHazmat::new(env).secp256k1_recover(&message_digest.0, signature, recovery_id)
     }
 
     /// Verifies the ECDSA secp256r1 signature.
@@ -228,14 +228,14 @@ impl CryptoHazmat {
         &self,
         message_digest: &BytesN<32>,
         signature: &BytesN<64>,
-        recorvery_id: u32,
+        recovery_id: u32,
     ) -> BytesN<65> {
         let env = self.env();
         let bytes = internal::Env::recover_key_ecdsa_secp256k1(
             env,
             message_digest.to_object(),
             signature.to_object(),
-            recorvery_id.into(),
+            recovery_id.into(),
         )
         .unwrap_infallible();
         unsafe { BytesN::unchecked_new(env.clone(), bytes) }

soroban-sdk/src/env.rs

@@ -39,7 +39,7 @@ pub mod internal {
     // any `TestContract` frame in progress and then _panics_, unwinding back to
     // a panic-catcher it installed when invoking the `TestContract` frame, and
     // then extracting E from the frame and returning it to its caller. This
-    // simulates the "crash, but catching the error" behaviour of the WASM case.
+    // simulates the "crash, but catching the error" behavior of the WASM case.
     // This only works if we panic via `escalate_error_to_panic`.
     //
     // (The reason we don't just panic_any() here and let the panic-catcher do a
@@ -725,7 +725,7 @@ impl Env {
     /// Take the return value with a grain of salt. The returned resources mostly
     /// correspond only to the operations that have happened during the host
     /// invocation, i.e. this won't try to simulate the work that happens in
-    /// production scenarios (e.g. certain XDR rountrips). This also doesn't try
+    /// production scenarios (e.g. certain XDR roundtrips). This also doesn't try
     /// to model resources related to the transaction size.
     ///
     /// The returned value is as useful as the preceding setup, e.g. if a test
@@ -749,7 +749,7 @@ impl Env {
     ///
     /// Pass the arguments for the contract's constructor, or `()` if none. For
     /// contracts with a constructor, use the contract's generated `Args` type
-    /// to construct the arguments with the appropropriate types for invoking
+    /// to construct the arguments with the appropriate types for invoking
     /// the constructor during registration.
     ///
     /// Returns the address of the registered contract that is the same as the
@@ -1120,15 +1120,15 @@ impl Env {
         self.env_impl
             .switch_to_recording_auth_inherited_from_snapshot(&prev_auth_manager)
             .unwrap();
-        self.invoke_contract::<()>(
+        let admin_result = self.try_invoke_contract::<(), Error>(
             &token_id,
             &soroban_sdk_macros::internal_symbol_short!("set_admin"),
             (admin,).try_into_val(self).unwrap(),
         );
         self.env_impl.set_auth_manager(prev_auth_manager).unwrap();
+        admin_result.unwrap().unwrap();
 
         let issuer = StellarAssetIssuer::new(self.clone(), issuer_id);
-
         StellarAssetContract::new(token_id, issuer, asset)
     }
 
@@ -1167,13 +1167,14 @@ impl Env {
         executable: xdr::ContractExecutable,
         constructor_args: Vec<Val>,
     ) -> Address {
+        let args_vec: std::vec::Vec<xdr::ScVal> =
+            constructor_args.iter().map(|v| v.into_val(self)).collect();
+        let constructor_args = args_vec.try_into().unwrap();
         let prev_auth_manager = self.env_impl.snapshot_auth_manager().unwrap();
         self.env_impl
             .switch_to_recording_auth_inherited_from_snapshot(&prev_auth_manager)
             .unwrap();
-        let args_vec: std::vec::Vec<xdr::ScVal> =
-            constructor_args.iter().map(|v| v.into_val(self)).collect();
-        let contract_id: Address = self
+        let create_result = self
             .env_impl
             .invoke_function(xdr::HostFunction::CreateContractV2(
                 xdr::CreateContractArgsV2 {
@@ -1186,16 +1187,13 @@ impl Env {
                         },
                     ),
                     executable,
-                    constructor_args: args_vec.try_into().unwrap(),
+                    constructor_args,
                 },
-            ))
-            .unwrap()
-            .try_into_val(self)
-            .unwrap();
+            ));
 
         self.env_impl.set_auth_manager(prev_auth_manager).unwrap();
 
-        contract_id
+        create_result.unwrap().try_into_val(self).unwrap()
     }
 
     /// Set authorizations and signatures in the environment which will be
@@ -1555,7 +1553,7 @@ impl Env {
     /// # fn main() {
     ///     let e: Env = Default::default();
     ///     let account_contract = NoopAccountContractClient::new(&e, &e.register(NoopAccountContract, ()));
-    ///     // Non-succesful call of `__check_auth` with a `contracterror` error.
+    ///     // Non-successful call of `__check_auth` with a `contracterror` error.
     ///     assert_eq!(
     ///         e.try_invoke_contract_check_auth::<NoopAccountError>(
     ///             &account_contract.address,

soroban-sdk/src/lib.rs

@@ -431,6 +431,22 @@ pub use soroban_sdk_macros::contract;
 /// Functions that are publicly accessible in the implementation are invocable
 /// by other contracts, or directly by transactions, when deployed.
 ///
+/// ### Notes
+///
+/// Each public function's export name is derived from the function name alone,
+/// without any type prefix or namespace. This means:
+///
+/// - **Function names must be unique across all `#[contractimpl]` blocks in a
+///   crate.** If two impl blocks define a function with the same name, their
+///   Wasm exports will collide, producing build or linker errors.
+///
+/// - **Importing a crate that contains `#[contractimpl]` blocks will pull its
+///   exported functions into the importing crate's Wasm binary.** This is a
+///   limitation of Rust — any `#[export_name = "..."]` function in a dependency
+///   is included in the final binary. This can cause unexpected exports or name
+///   collisions that are hard to diagnose. For this reason it is usually
+///   inadvisable to import dependencies that use `#[contractimpl]`.
+///
 /// ### Examples
 ///
 /// Define a contract with one function, `hello`, and call it from within a test

soroban-sdk/src/tests/env.rs

@@ -14,7 +14,7 @@ use crate::{
 // configured for real. Some functions in Env have in the past or may now make
 // assumptions about a source account being set. This is something small we do
 // to make sure we don't accidentally introduce Env functionality that will
-// panick in SDK tests.
+// panic in SDK tests.
 fn default_has_source_account_configured_in_host() {
     let env = Env::default();
     assert!(env.host().source_account_address().unwrap().is_some());
@@ -44,6 +44,11 @@ enum ContractError {
     AnError = 1,
 }
 
+mod constructor_contract {
+    use crate as soroban_sdk;
+    soroban_sdk::contractimport!(file = "../target/wasm32v1-none/release/test_constructor.wasm");
+}
+
 #[test]
 fn default_and_from_snapshot_same_settings() {
     let env1 = Env::default();
@@ -326,3 +331,28 @@ fn test_try_as_contract_panic() {
         )))
     );
 }
+
+#[test]
+fn test_register_restores_auth_before_panics() {
+    let env = Env::default();
+
+    let address = env.register(Contract, ());
+    let client = ContractClient::new(&env, &address);
+    let user = Address::generate(&env);
+
+    let pre_register = client.try_need_auth(&user);
+    assert!(pre_register.is_err());
+
+    // This is contrived to cause a panic inside register_contract_with_source.
+    // Don't actually do things like this!
+    let another_contract = env.register(Contract, ());
+    let register_result = env.try_as_contract::<_, Error>(&another_contract, || {
+        // This expects arguments for the constructor, but none are provided, so it will panic
+        env.register(constructor_contract::WASM, ());
+    });
+    assert!(register_result.is_err());
+
+    let post_register = client.try_need_auth(&user);
+    assert!(post_register.is_err());
+    assert_eq!(pre_register, post_register);
+}

soroban-sdk/src/testutils.rs

@@ -336,7 +336,7 @@ pub mod budget {
 
     /// Budget that tracks the resources consumed for the environment.
     ///
-    /// The budget consistents of two cost dimensions:
+    /// The budget consists of two cost dimensions:
     ///  - CPU instructions
     ///  - Memory
     ///

soroban-sdk/test_snapshots/tests/env/test_register_restores_auth_before_panics.1.json

@@ -0,0 +1,87 @@
+{
+  "generators": {
+    "address": 4,
+    "nonce": 0,
+    "mux_id": 0
+  },
+  "auth": [
+    [],
+    [],
+    [],
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 25,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_data": {
+              "ext": "v0",
+              "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHK3M",
+              "key": "ledger_key_contract_instance",
+              "durability": "persistent",
+              "val": {
+                "contract_instance": {
+                  "executable": {
+                    "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                  },
+                  "storage": null
+                }
+              }
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      },
+      {
+        "entry": {
+          "last_modified_ledger_seq": 0,
+          "data": {
+            "contract_code": {
+              "ext": "v0",
+              "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+              "code": ""
+            }
+          },
+          "ext": "v0"
+        },
+        "live_until": 4095
+      }
+    ]
+  },
+  "events": []
+}

soroban-token-sdk/src/_migrating/v23_token_transfer.rs

@@ -75,7 +75,5 @@
 //! don't require any changes, because the [`MuxedAddress`] is only necessary
 //! in a few narrow scenarios (such as direct transfer to an exchange).
 //!
-//! [`Events::publish`]: crate::events::Events::publish
-//! [`Address`]: crate::MuxedAddress
-//! [`MuxedAddress`]: crate::MuxedAddress
-//! [`contractevent`]: crate::contractevent
+//! [`Address`]: soroban_sdk::Address
+//! [`MuxedAddress`]: soroban_sdk::MuxedAddress