Remove the caching of authenticated_signer / authenticated_caller_id in contract calls. (#4374)

## Motivation

The `authenticated_signer` / `authenticated_caller_id` were cached in
the `linera-sdk`.
This is incorrect, since it varies from one call to another.

## Proposal

Caching was removed.

## Test Plan

The CI.

The test of the feature is done with a smart contract `contract-call`.
It is tested in the integration test.
Without this correction, the test fails. The test could not be put at a
lower level like `linera-core` or `linera-execution`
since those do not use the `linera-sdk`.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

examples/Cargo.lock

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "amm",
     "call-evm-counter",
+    "contract-call",
     "counter",
     "counter-no-graphql",
     "create-and-call",

examples/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "contract-call"
+version = "0.1.0"
+authors = ["Linera <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+linera-sdk = { path = "../../linera-sdk" }
+serde = { version = "1.0.152", features = ["derive"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+linera-sdk = { workspace = true, features = ["test", "wasmer"] }
+tokio.workspace = true
+
+[[bin]]
+name = "contract_call_contract"
+path = "src/contract.rs"
+
+[[bin]]
+name = "contract_call_service"
+path = "src/service.rs"

examples/contract-call/Cargo.toml

@@ -0,0 +1,8 @@
+# Contract call
+
+This example illustrates the access to `authenticated_signer` and `authenticated_caller_id`
+in contract calls.
+
+It also illustrates that how a system call has access to the `authenticated_caller_id`
+even in non authenticated calls.
+

examples/contract-call/README.md

@@ -0,0 +1,122 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+use contract_call::{ContractTransferAbi, Operation, Parameters};
+use linera_sdk::{
+    linera_base_types::{Account, ApplicationId, WithContractAbi},
+    Contract, ContractRuntime,
+};
+
+pub struct ContractTransferContract {
+    runtime: ContractRuntime<Self>,
+}
+
+linera_sdk::contract!(ContractTransferContract);
+
+impl WithContractAbi for ContractTransferContract {
+    type Abi = ContractTransferAbi;
+}
+
+impl Contract for ContractTransferContract {
+    type Message = ();
+    type InstantiationArgument = ();
+    type Parameters = Parameters;
+    type EventValue = ();
+
+    async fn load(runtime: ContractRuntime<Self>) -> Self {
+        ContractTransferContract { runtime }
+    }
+
+    async fn instantiate(&mut self, _value: ()) {
+        // Validate that the application parameters were configured correctly.
+        self.runtime.application_parameters();
+    }
+
+    async fn execute_operation(&mut self, operation: Operation) {
+        match operation {
+            Operation::DirectTransfer {
+                source,
+                destination,
+                amount,
+            } => {
+                // Direct transfer using runtime.transfer
+                self.runtime.transfer(source, destination, amount);
+            }
+            Operation::IndirectTransfer {
+                source,
+                destination,
+                amount,
+            } => {
+                // Indirect transfer: create application, transfer to it, then transfer from it
+                let module_id = self.runtime.application_parameters().module_id;
+                //                let typed_module_id: ModuleId<ContractTransferAbi, Parameters, ()> = module_id.with_abi();
+
+                // Create a new application instance
+                let parameters = self.runtime.application_parameters();
+                let application_id = self
+                    .runtime
+                    .create_application::<ContractTransferAbi, Parameters, ()>(
+                        module_id,
+                        &parameters,
+                        &(),
+                        vec![],
+                    );
+
+                // Transfer from source to the created application
+                let chain_id = self.runtime.chain_id();
+                let app_account = Account {
+                    chain_id,
+                    owner: application_id.into(),
+                };
+                self.runtime.transfer(source, app_account, amount);
+
+                // Authenticated calls should be fully visible.
+                let operation = Operation::TestSomeAuthenticatedSignerCaller;
+                self.runtime
+                    .call_application(true, application_id, &operation);
+
+                // Non-authenticated calls should be fully non-visible
+                let operation = Operation::TestNoneAuthenticatedSignerCaller;
+                self.runtime
+                    .call_application(false, application_id, &operation);
+
+                // Non-authenticated calls should be fully non-visible
+                let operation = Operation::TestNoneAuthenticatedSignerCaller;
+                self.runtime
+                    .call_application(false, application_id, &operation);
+
+                // Authenticated calls should be fully visible.
+                let operation = Operation::TestSomeAuthenticatedSignerCaller;
+                self.runtime
+                    .call_application(true, application_id, &operation);
+
+                // Call the created application to transfer from itself to destination.
+                // Authenticated or not, the system is able to access the caller
+                // for making the transfer.
+                let operation = Operation::DirectTransfer {
+                    source: ApplicationId::into(application_id),
+                    destination,
+                    amount,
+                };
+                self.runtime
+                    .call_application(false, application_id, &operation);
+            }
+            Operation::TestNoneAuthenticatedSignerCaller => {
+                assert!(self.runtime.authenticated_signer().is_none());
+                assert!(self.runtime.authenticated_caller_id().is_none());
+            }
+            Operation::TestSomeAuthenticatedSignerCaller => {
+                assert!(self.runtime.authenticated_signer().is_some());
+                assert!(self.runtime.authenticated_caller_id().is_some());
+            }
+        }
+    }
+
+    async fn execute_message(&mut self, _message: ()) {
+        panic!("Contract transfer application doesn't support any cross-chain messages");
+    }
+
+    async fn store(self) {}
+}

examples/contract-call/src/contract.rs

@@ -0,0 +1,54 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+use linera_sdk::linera_base_types::{
+    Account, AccountOwner, Amount, ContractAbi, ModuleId, ServiceAbi,
+};
+use serde::{Deserialize, Serialize};
+
+pub struct ContractTransferAbi;
+
+impl ContractAbi for ContractTransferAbi {
+    type Operation = Operation;
+    type Response = ();
+}
+
+impl ServiceAbi for ContractTransferAbi {
+    type Query = Query;
+    type QueryResponse = ();
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Operation {
+    DirectTransfer {
+        source: AccountOwner,
+        destination: Account,
+        amount: Amount,
+    },
+    IndirectTransfer {
+        source: AccountOwner,
+        destination: Account,
+        amount: Amount,
+    },
+    TestNoneAuthenticatedSignerCaller,
+    TestSomeAuthenticatedSignerCaller,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Query {
+    DirectTransfer {
+        source: AccountOwner,
+        destination: Account,
+        amount: Amount,
+    },
+    IndirectTransfer {
+        source: AccountOwner,
+        destination: Account,
+        amount: Amount,
+    },
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Parameters {
+    pub module_id: ModuleId,
+}

examples/contract-call/src/lib.rs

@@ -0,0 +1,58 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+#![cfg_attr(target_arch = "wasm32", no_main)]
+
+use std::sync::Arc;
+
+use contract_call::{ContractTransferAbi, Operation, Parameters, Query};
+use linera_sdk::{linera_base_types::WithServiceAbi, Service, ServiceRuntime};
+
+pub struct ContractTransferService {
+    runtime: Arc<ServiceRuntime<Self>>,
+}
+
+linera_sdk::service!(ContractTransferService);
+
+impl WithServiceAbi for ContractTransferService {
+    type Abi = ContractTransferAbi;
+}
+
+impl Service for ContractTransferService {
+    type Parameters = Parameters;
+
+    async fn new(runtime: ServiceRuntime<Self>) -> Self {
+        ContractTransferService {
+            runtime: Arc::new(runtime),
+        }
+    }
+
+    async fn handle_query(&self, request: Query) {
+        match request {
+            Query::DirectTransfer {
+                source,
+                destination,
+                amount,
+            } => {
+                let operation = Operation::DirectTransfer {
+                    source,
+                    destination,
+                    amount,
+                };
+                self.runtime.schedule_operation(&operation);
+            }
+            Query::IndirectTransfer {
+                source,
+                destination,
+                amount,
+            } => {
+                let operation = Operation::IndirectTransfer {
+                    source,
+                    destination,
+                    amount,
+                };
+                self.runtime.schedule_operation(&operation);
+            }
+        }
+    }
+}

examples/contract-call/src/service.rs

@@ -0,0 +1,82 @@
+// Copyright (c) Zefchain Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Integration tests for the Contract Call application
+
+#![cfg(not(target_arch = "wasm32"))]
+
+use contract_call::{ContractTransferAbi, Parameters};
+use linera_sdk::{
+    linera_base_types::{Account, AccountOwner, Amount},
+    test::TestValidator,
+};
+
+/// Test that mimics the end-to-end contract call test from linera_net_tests.rs
+/// This test creates two accounts, publishes the contract-call module,
+/// creates an application, and tests indirect transfer functionality.
+#[tokio::test]
+async fn test_contract_call_integration() {
+    use contract_call::Operation;
+    let (validator, module_id) =
+        TestValidator::with_current_module::<ContractTransferAbi, Parameters, ()>().await;
+
+    let mut chain = validator.new_chain().await;
+    let owner1 = AccountOwner::from(chain.public_key());
+    let account1 = Account {
+        chain_id: chain.id(),
+        owner: owner1,
+    };
+
+    let transfer_amount = Amount::from_tokens(100);
+    let funding_chain = validator.get_chain(&validator.admin_chain_id());
+    let transfer_certificate = funding_chain
+        .add_block(|block| {
+            block.with_native_token_transfer(AccountOwner::CHAIN, account1, transfer_amount);
+        })
+        .await;
+    chain
+        .add_block(|block| {
+            block.with_messages_from(&transfer_certificate);
+        })
+        .await;
+
+    // Generate a second owner
+    let second_chain = validator.new_chain().await;
+    let owner2 = AccountOwner::from(second_chain.public_key());
+
+    // Create accounts for both owners
+    let account2 = Account {
+        chain_id: chain.id(),
+        owner: owner2,
+    };
+
+    // Give initial balance to the first account (simulating the transfer_with_accounts)
+    // In the test environment, chains start with default balance
+
+    // Create parameters for the application
+    let parameters = Parameters {
+        module_id: module_id.forget_abi(),
+    };
+
+    // Create the application
+    let application_id = chain
+        .create_application(module_id, parameters, (), vec![])
+        .await;
+
+    // Test indirect transfer: transfer from owner1 to owner2 via application
+    let transfer_amount = Amount::from_tokens(1);
+
+    // Use Operation to trigger indirect transfer operation
+    let operation = Operation::IndirectTransfer {
+        source: owner1,
+        destination: account2,
+        amount: transfer_amount,
+    };
+
+    // Add a block with the operation
+    chain
+        .add_block(|block| {
+            block.with_operation(application_id, operation);
+        })
+        .await;
+}