Cross Contract Call

#[private] // Public - but only callable by env::current_account_id()
pub fn ll_query_greeting_callback(
    &self,
    #[callback_result] call_result: Result<String, PromiseError>,
) -> String {
    // Check if the promise succeeded by calling the method outlined in external.rs
    if call_result.is_err() {
        log!("There was an error contacting Hello NEAR");
        return "".to_string();
    }

    // Return the greeting
    let greeting: String = call_result.unwrap();
    greeting
}

#[path = "../../test-utils/mod.rs"]
mod common;

use common::{build_contract, TestResult, TestSandbox};
use serde_json::json;

#[tokio::test]
async fn high_and_low_level_cross_contract_calls() -> TestResult {
    let hello_wasm = build_contract("tests/hello-near/Cargo.toml")?;
    let contract_wasm = build_contract("Cargo.toml")?;
    let sandbox = TestSandbox::start().await?;
    let hello = sandbox.deploy("hello.sandbox", hello_wasm).await?;
    let contract = sandbox
        .deploy("cross-contract.sandbox", contract_wasm)
        .await?;
    let alice = sandbox.create_account("alice.sandbox").await?;
    sandbox
        .call(
            &contract,
            &contract,
            "init",
            json!({ "hello_account": hello }),
        )
        .await?;

    let greeting = sandbox
        .call(&alice, &contract, "hl_query_greeting", json!({}))
        .await?;
    assert_eq!(greeting, json!("Hello"));

    let changed = sandbox
        .call(
            &alice,
            &contract,
            "hl_change_greeting",
            json!({ "new_greeting": "Howdy" }),
        )
        .await?;
    assert_eq!(changed, json!(true));
    let greeting = sandbox
        .call(&alice, &contract, "hl_query_greeting", json!({}))
        .await?;
    assert_eq!(greeting, json!("Howdy"));

    let changed = sandbox
        .call(
            &alice,
            &contract,
            "ll_change_greeting",
            json!({ "new_greeting": "Hello" }),
        )
        .await?;
    assert_eq!(changed, json!(true));
    let greeting = sandbox
        .call(&alice, &contract, "ll_query_greeting", json!({}))
        .await?;
    assert_eq!(greeting, json!("Hello"));
    Ok(())
}

pub fn batch_actions(&mut self) -> Promise {
    let hi = json!({ "greeting": "hi" }).to_string().into_bytes();
    let bye = json!({ "greeting": "bye" }).to_string().into_bytes();

    // You can create one transaction calling multiple methods
    // on a same contract
    Promise::new(self.hello_account.clone())
        .function_call("set_greeting".to_owned(), hi, NO_DEPOSIT, XCC_GAS)
        .function_call("get_greeting".to_owned(), NO_ARGS, NO_DEPOSIT, XCC_GAS)
        .function_call("set_greeting".to_owned(), bye, NO_DEPOSIT, XCC_GAS)
        .function_call("get_greeting".to_owned(), NO_ARGS, NO_DEPOSIT, XCC_GAS)
        .then(Self::ext(env::current_account_id()).batch_actions_callback())
}

#[private]
pub fn batch_actions_callback(
    &self,
    #[callback_result] last_result: Result<String, PromiseError>,
) -> String {
    // The callback only has access to the last action's result
    if let Ok(result) = last_result {
        log!("The last result is {result}");
        result
    } else {
        log!("The batch call failed and all calls got reverted");
        "".to_string()
    }
}

/// A method which calls different contracts via cross contract function calls.
pub fn multiple_contracts(&mut self) -> Promise {
    // We create a promise that calls the `get_greeting` function on the HELLO_CONTRACT
    let hello_promise = Promise::new(self.hello_account.clone()).function_call(
        "get_greeting".to_owned(),
        NO_ARGS,
        NO_DEPOSIT,
        XCC_GAS,
    );

    // We create a promise that calls the `get_num` function on the COUNTER_CONTRACT
    let counter_promise = Promise::new(self.counter_account.clone()).function_call(
        "get_num".to_owned(),
        NO_ARGS,
        NO_DEPOSIT,
        XCC_GAS,
    );

    // We create a promise that calls the `get_messages` function on the GUESTBOOK_CONTRACT
    let args = json!({ "from_index": "0", "limit": 2 })
        .to_string()
        .into_bytes();

    let guestbook_promise = Promise::new(self.guestbook_account.clone()).function_call(
        "get_messages".to_owned(),
        args,
        NO_DEPOSIT,
        XCC_GAS,
    );

    // We join all promises and chain a callback to collect their results.
    hello_promise
        .and(counter_promise)
        .and(guestbook_promise)
        .then(
            Self::ext(env::current_account_id())
                .with_static_gas(XCC_GAS)
                .multiple_contracts_callback(),
        )
}

#[private]
pub fn multiple_contracts_callback(
    &self,
    #[callback_result] hello_result: Result<String, PromiseError>,
    #[callback_result] counter_result: Result<i8, PromiseError>,
    #[callback_result] guestbook_result: Result<Vec<PostedMessage>, PromiseError>,
) -> (String, i8, Vec<PostedMessage>) {
    // The callback has access to the result of the 3 calls
    let greeting = if let Ok(result) = hello_result {
        log!("HelloNear says {result}");
        result
    } else {
        log!("The call to HelloNear failed");
        "".to_string()
    };

    let counter = if let Ok(result) = counter_result {
        log!("Counter is {result}");
        result
    } else {
        log!("The call to Counter failed");
        0
    };

    let messages = if let Ok(result) = guestbook_result {
        log!("The messages are {result:?}");
        result
    } else {
        log!("The call to GuestBook failed");
        vec![]
    };

    (greeting, counter, messages)
}

fn promise_set_get(&self, message: &str) -> Promise {
    // Aux method to create a batch transaction calling
    // set_message and get_message in the HELLO CONTRACT
    let args = json!({ "greeting": message }).to_string().into_bytes();

    Promise::new(self.hello_account.clone())
        .function_call("set_greeting".to_owned(), args, NO_DEPOSIT, XCC_GAS)
        .function_call("get_greeting".to_owned(), NO_ARGS, NO_DEPOSIT, XCC_GAS)
}

pub fn similar_contracts(&mut self) -> Promise {
    // Create promises to call 3 contracts that return the same type
    // For simplicity here we call the same contract
    let hello_one = self.promise_set_get("hi");
    let hello_two = self.promise_set_get("howdy");
    let hello_three = self.promise_set_get("bye");

    // Join all promises and chain a callback to collect their results.
    hello_one.and(hello_two).and(hello_three).then(
        Self::ext(env::current_account_id())
            .with_static_gas(XCC_GAS)
            .similar_contracts_callback(3),
    )
}

#[private]
pub fn similar_contracts_callback(&self, number_promises: u64) -> Vec<String> {
    (0..number_promises)
        .filter_map(|index| {
            // env::promise_result(i) has the result of the i-th call
            let result = env::promise_result(index);

            match result {
                PromiseResult::Failed => {
                    log!("Promise number {index} failed.");
                    None
                }
                PromiseResult::Successful(value) => {
                    if let Ok(message) = near_sdk::serde_json::from_slice::<String>(&value) {
                        log!("Call {index} returned: {message}");
                        Some(message)
                    } else {
                        log!("Error deserializing call {index} result.");
                        None
                    }
                }
            }
        })
        .collect()
}