How to call a contract function with subxt?

[chriamue]

I need assistance on how to properly call a contract function in Rust that compiles to wasm. The following methods I've tried aren't functioning as expected.

Based on this example I created a psp22 token contract.

Running contract call which uses subxt works.

cargo contract call --contract 5FmHL1qCfDPQMjzbP9wwXFvdF2GKPP8TqZHLQv5UeuAd6gLn --message PSP22::total_supply --suri //Alice
      Result Ok(1000000000000000000)
    Reverted false
Your message call has not been executed.
To submit the transaction and execute the call on chain, add -x/--execute flag to the command.

When looking into the sources of cargo-contract,
there is a transcoder.encode(&self.message, &self.args) function, which seems not too simple to reproduce, as it depends on the compiled contract artifacts.

Also the tx_call integration_test is not so easy to understand, how maybe to use the cargo contract generated artifacts.

An older Stackoverflow answer guided me to this peace of code, that does not work:

...
use blake2::{Blake2s256, Digest};
use subxt_signer::sr25519::dev;
use polkadot::contracts::calls::types::Call;
use polkadot::runtime_types::sp_weights::weight_v2::Weight;
use subxt::ext::codec::{Decode, Encode};
use subxt::tx::Payload;
use subxt::utils::AccountId32;
use subxt::utils::MultiAddress;

#[subxt::subxt(runtime_metadata_path = "metadata.scale")]
pub mod polkadot {}

const PROOF_SIZE: u64 = u64::MAX / 2;

fn blake2_256(input: &[u8]) -> Vec<u8> {
    let mut hasher = Blake2s256::new();
    hasher.update(input);
    hasher.finalize().to_vec()
}

fn create_playload() -> Payload<Call> {

    let contract = "5FmHL1qCfDPQMjzbP9wwXFvdF2GKPP8TqZHLQv5UeuAd6gLn";

    let mut call_data = Vec::<u8>::new();
    call_data.append(&mut (&blake2_256("PSP22::total_supply".as_bytes())[0..4]).to_vec());

    polkadot::tx().contracts().call(
        AccountId32::from_str(contract).unwrap().into(),
        0,
        Weight {
            ref_time: 500_000_000_000,
            proof_size: PROOF_SIZE,
        },
        None,
        call_data,
    )
}

let payload = create_playload();
...
let result =  api.tx()
    .sign_and_submit_then_watch_default(&payload, &dev::alice())
    .await.unwrap().wait_for_finalized_success()
    .await.unwrap();
    web_sys::console::log_1(&format!("Run Result: {:?}", result).into());

The file metadata.scale was created using: subxt metadata --pallets Contracts,System -f bytes > metadata.scale

.wait_for_finalized_success() hangs so console log never prints.

[lavrd]

@chriamue did you solve your problem? Your result cannot be finalized as you probably run substrate-contracts-node and in this node blocks are not finalizing. But did you figure out how to properly call method using subxt?

[chriamue]

Thank you for the information that blocks actual don't finalize.
I see in the actual main branch of substrate-contracts-node is a new parameter --finalize-delay-sec.
I hope this will resolve my issue in the next release.

[jsdw]

Because the substrate-contracts-node doesn't finalize blocks, the usual wait_for_finalized style calls in Subxt will wait forever (nothing ever finalizes). Instead, you can fall back to the lower level APIs and do something like:

let mut tx_progress = api.tx()
    .sign_and_submit_then_watch_default(&payload, &dev::alice())
    .await
    .unwrap();

// Instead of using the high level `wait_for_finalized_success` API,
// which doesn't help if nothing ever finalizes, we can fall back to
// the "low level" API and wait for the relevant block events instead:
while let Some(ev) = tx_progress.next().await {
    // bail if any error encountered with "?".
    let ev = ev?;

    let block = match ev {
        // Finalized! Here we just break the loop but you could return the result of
        // `wait_for_success()` too.
        TxStatus::InFinalizedBlock(b) | TxStatus::InBestBlock(b) => {
            block.wait_for_success().await.unwrap();
            break;
        },
        // Error scenarios; handle the error somehow (below is what Subxt would return).
        TxStatus::Error { message } => {
            return Err(TransactionError::Error(message).into())
        }
        TxStatus::Invalid { message } => {
            return Err(TransactionError::Invalid(message).into())
        }
        TxStatus::Dropped { message } => {
            return Err(TransactionError::Dropped(message).into())
        }
        // Ignore and wait for next status event:
        _ => continue,
    };
}

This logic could be wrapped up into a function if you call it a lot for convenience.

[lavrd]

Is it possible to provide additional example how to interact, for example, with Flipper ink! contract which is deployed to substrate-contracts-node?

I didn't find any examples/docs how to do it. From exploring source code of AlephZero client and cargo contract I finally figured out how to call flip method.

Still have some problems: I added some logs to smart contract, when I use cargo contract I can see them in node logs, but I don't see them when I use my source code in Rust for smart contract calling, but I am sure that methods is called because with both ways I can see events.

And still exploring how to read data from get method, mostly about response deserialization.

[lavrd]

Finally figured out how to do it :) I will prepare new example for future and make a PR if it is okay.

But still have some strange behavior, flip method doesn't produce logs (ink::env::debug_println!), but get method is ok. Can it be because get is executing as dry run but flip not?