Merge branch 'master' into ironcev/abi-backtracing-trace-attribute

Author: tritao

Cargo.lock

@@ -251,3 +251,5 @@ Durations
 durations
 invariants
 postfix
+impl
+Impl

docs/book/spell-check-custom-words.txt

@@ -5,11 +5,11 @@
 A smart contract is no different than a script or predicate in that it is a piece of bytecode that is deployed to the blockchain via a [transaction](https://fuellabs.github.io/fuel-specs/master/protocol/tx_format). The main features of a smart contract that differentiate it from scripts or predicates are that it is _callable_ and _stateful_. Put another way, a smart contract is analogous to a deployed API with some database state.
 <!-- contract:example:end -->
 
-The interface of a smart contract, also just called a contract, must be defined strictly with an [ABI declaration](#the-abi-declaration). See [this contract](../examples/wallet_smart_contract.md) for an example.
+The interface of a smart contract, also just called a contract, can be explicitly defined with an [ABI declaration](#the-abi-declaration) or implicitly with an [impl Self](#impl-self-contracts) item for the special type "Contract". See [this contract](../examples/wallet_smart_contract.md) for an example on using ABIs.
 
 ## Syntax of a Smart Contract
 
-As with any Sway program, the program starts with a declaration of what [program type](./index.md) it is. A contract must also either define or import an [ABI declaration](#the-abi-declaration) and implement it.
+As with any Sway program, the program starts with a declaration of what [program type](./index.md) it is. When using ABIs, a contract must either define or import an [ABI declaration](#the-abi-declaration) and implement it.
 
 <!-- This section should explain best practices for ABIs -->
 <!-- ABI:example:start -->
@@ -100,3 +100,21 @@ Each special parameter is optional and assumes a default value when skipped:
 1. The default value for `gas` is the context gas (i.e. the content of the special register `$cgas`). Refer to the [FuelVM specifications](https://fuellabs.github.io/fuel-specs/master/vm) for more information about context gas.
 2. The default value for `coins` is 0.
 3. The default value for `asset_id` is `b256::zero()`.
+
+## Impl Self Contracts
+
+In some cases, it may be more convenient to avoid declaring an ABI and implement the contract directly, as shown in the example below.
+
+Notice how there is no ABI specified in the `impl` item. In this case, the compiler will automatically create an ABI named as the package containing this `impl Contract` item, and will include each function in the ABI.
+
+```sway
+{{#include ../../../../examples/wallet_smart_contract_self_impl/src/main.sw:abi_impl}}
+```
+
+Without an ABI, there is no way for scripts and other contracts to use `abi(...)` and call this contract, but it can still be tested and called using any of available SDKs, as any other contract.
+
+The ABI name will be the "upper camel case" version of the package name containing the "impl Contract" item. `CONTRACT_ID` is a compiler special constant that references the contract being implemented in this file.
+
+```sway
+{{#include ../../../../examples/wallet_smart_contract_self_impl/src/main.sw:tests}}
+```

docs/book/src/sway-program-types/smart_contracts.md

@@ -194,3 +194,8 @@ dependencies = [
     "std",
     "wallet_abi",
 ]
+
+[[package]]
+name = "wallet_smart_contract_self_impl"
+source = "member"
+dependencies = ["std"]

examples/Forc.lock

@@ -41,4 +41,5 @@ members = [
   "wallet_abi",
   "wallet_contract_caller_script",
   "wallet_smart_contract",
+  "wallet_smart_contract_self_impl",
 ]

examples/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <[email protected]>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "wallet_smart_contract_self_impl"
+
+[dependencies]
+std = { path = "../../sway-lib-std" }

examples/wallet_smart_contract_self_impl/Forc.toml

@@ -0,0 +1,57 @@
+// ANCHOR: full_wallet
+contract;
+
+use std::{asset::transfer, call_frames::msg_asset_id, context::msg_amount};
+
+const OWNER_ADDRESS = Address::from(0x8900c5bec4ca97d4febf9ceb4754a60d782abbf3cd815836c1872116f203f861);
+
+storage {
+    balance: u64 = 0,
+}
+
+// ANCHOR: abi_impl
+impl Contract {
+    #[storage(read, write), payable]
+    fn receive_funds() {
+        if msg_asset_id() == AssetId::base() {
+            // If we received the base asset then keep track of the balance.
+            // Otherwise, we're receiving other native assets and don't care
+            // about our balance of coins.
+            storage.balance.write(storage.balance.read() + msg_amount());
+        }
+    }
+
+    #[storage(read, write)]
+    fn send_funds(amount_to_send: u64, recipient_address: Address) {
+        let sender = msg_sender().unwrap();
+        match sender {
+            Identity::Address(addr) => assert(addr == OWNER_ADDRESS),
+            _ => revert(0),
+        };
+
+        let current_balance = storage.balance.read();
+        assert(current_balance >= amount_to_send);
+
+        storage.balance.write(current_balance - amount_to_send);
+
+        // Note: `transfer()` is not a call and thus not an
+        // interaction. Regardless, this code conforms to
+        // checks-effects-interactions to avoid re-entrancy.
+        transfer(
+            Identity::Address(recipient_address),
+            AssetId::base(),
+            amount_to_send,
+        );
+    }
+}
+// ANCHOR_END: abi_impl
+
+// ANCHOR: tests
+#[test]
+fn tests() {
+    let w = abi(WalletSmartContractSelfImpl, CONTRACT_ID);
+    w.receive_funds();
+}
+// ANCHOR_END: tests
+
+// ANCHOR_END: full_wallet

examples/wallet_smart_contract_self_impl/src/main.sw

@@ -48,6 +48,7 @@ sway-types.workspace = true
 sway-utils.workspace = true
 swayfmt.workspace = true
 thiserror.workspace = true
+toml = { workspace = true, features = ["parse"] }
 tracing.workspace = true
 uint.workspace = true
 vec1.workspace = true

sway-core/Cargo.toml

@@ -98,9 +98,17 @@ pub fn parse(
     engines: &Engines,
     config: Option<&BuildConfig>,
     experimental: ExperimentalFeatures,
+    package_name: &str,
 ) -> Result<(lexed::LexedProgram, parsed::ParseProgram), ErrorEmitted> {
     match config {
-        None => parse_in_memory(handler, engines, src, experimental, DbgGeneration::None),
+        None => parse_in_memory(
+            handler,
+            engines,
+            src,
+            experimental,
+            DbgGeneration::None,
+            package_name,
+        ),
         // When a `BuildConfig` is given,
         // the module source may declare `mod`s that must be parsed from other files.
         Some(config) => parse_module_tree(
@@ -114,6 +122,7 @@ pub fn parse(
             config.include_tests,
             experimental,
             config.lsp_mode.as_ref(),
+            package_name,
         )
         .map(
             |ParsedModuleTree {
@@ -371,6 +380,7 @@ fn parse_in_memory(
     src: Source,
     experimental: ExperimentalFeatures,
     dbg_generation: DbgGeneration,
+    package_name: &str,
 ) -> Result<(lexed::LexedProgram, parsed::ParseProgram), ErrorEmitted> {
     let mut hasher = DefaultHasher::new();
     src.text.hash(&mut hasher);
@@ -385,7 +395,12 @@ fn parse_in_memory(
     let attributes_error_emitted = handler.append(attributes_handler);
 
     let (kind, tree) = to_parsed_lang::convert_parse_tree(
-        &mut to_parsed_lang::Context::new(BuildTarget::EVM, dbg_generation, experimental),
+        &mut to_parsed_lang::Context::new(
+            BuildTarget::EVM,
+            dbg_generation,
+            experimental,
+            package_name,
+        ),
         handler,
         engines,
         module.value.clone(),
@@ -438,6 +453,7 @@ fn parse_submodules(
     include_tests: bool,
     experimental: ExperimentalFeatures,
     lsp_mode: Option<&LspConfig>,
+    package_name: &str,
 ) -> Submodules {
     // Assume the happy path, so there'll be as many submodules as dependencies, but no more.
     let mut submods = Vec::with_capacity(module.submodules().count());
@@ -471,6 +487,7 @@ fn parse_submodules(
             include_tests,
             experimental,
             lsp_mode,
+            package_name,
         ) {
             if !matches!(kind, parsed::TreeType::Library) {
                 let source_id = engines.se().get_source_id(submod_path.as_ref());
@@ -525,6 +542,7 @@ fn parse_module_tree(
     include_tests: bool,
     experimental: ExperimentalFeatures,
     lsp_mode: Option<&LspConfig>,
+    package_name: &str,
 ) -> Result<ParsedModuleTree, ErrorEmitted> {
     let query_engine = engines.qe();
 
@@ -546,6 +564,7 @@ fn parse_module_tree(
         include_tests,
         experimental,
         lsp_mode,
+        package_name,
     );
 
     let (attributes_handler, attributes) = attr_decls_to_attributes(
@@ -557,7 +576,7 @@ fn parse_module_tree(
 
     // Convert from the raw parsed module to the `ParseTree` ready for type-check.
     let (kind, tree) = to_parsed_lang::convert_parse_tree(
-        &mut to_parsed_lang::Context::new(build_target, dbg_generation, experimental),
+        &mut to_parsed_lang::Context::new(build_target, dbg_generation, experimental, package_name),
         handler,
         engines,
         module.value.clone(),
@@ -1006,7 +1025,14 @@ pub fn compile_to_ast(
         package_name,
         "parse the program to a concrete syntax tree (CST)",
         "parse_cst",
-        parse(src, handler, engines, build_config, experimental),
+        parse(
+            src,
+            handler,
+            engines,
+            build_config,
+            experimental,
+            package_name
+        ),
         build_config,
         metrics
     );
@@ -1521,6 +1547,7 @@ fn test_basic_prog() {
         &engines,
         None,
         ExperimentalFeatures::default(),
+        "test",
     );
     prog.unwrap();
 }
@@ -1541,6 +1568,7 @@ fn test_parenthesized() {
         &engines,
         None,
         ExperimentalFeatures::default(),
+        "test",
     );
     prog.unwrap();
 }
@@ -1563,6 +1591,7 @@ fn test_unary_ordering() {
         &engines,
         None,
         ExperimentalFeatures::default(),
+        "test",
     );
     let (.., prog) = prog.unwrap();
     // this should parse as `(!a) && b`, not `!(a && b)`. So, the top level
@@ -1612,6 +1641,7 @@ fn test_parser_recovery() {
         &engines,
         None,
         ExperimentalFeatures::default(),
+        "test",
     );
     let (_, _) = prog.unwrap();
     assert!(handler.has_errors());

sway-core/src/lib.rs

@@ -160,6 +160,7 @@ where
             crate::BuildTarget::Fuel,
             dbg_generation,
             self.ctx.experimental,
+            "", // this is only used for self impl contracts
         );
 
         let handler = Handler::default();
@@ -236,6 +237,7 @@ where
             BuildTarget::Fuel,
             dbg_generation,
             self.ctx.experimental,
+            "", // this is only used for self impl contracts
         );
 
         let handler = Handler::default();