Functions for rust frontend

[silicology1]

cargo contract is a cli, can it provide functions for making transaction with ink contract that can be used with rust wasm frontend like leptos, contract rust sdk not just cli.

[silicology1]

Successfully implemented transaction, but unable to do get request and fetch data.

Code for transaction:

#![allow(missing_docs)]
use subxt::{OnlineClient, PolkadotConfig};
use subxt_signer::sr25519::dev;
use blake2::{Blake2s256, Digest};
use subxt::utils::AccountId32;
use std::str::FromStr;
use polkadot::runtime_types::sp_weights::weight_v2::Weight;
use subxt::tx::TxStatus;
use ink_metadata::InkProject;
use parity_scale_codec::{Encode, Decode};
use std::fs;
use anyhow::{Result, anyhow};
// Generate an interface that we can use from the node's metadata.
#[subxt::subxt(runtime_metadata_path = "./artifacts/metadata.scale",)]
pub mod polkadot {}

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



fn generate_call_data(metadata_path: &str, method_name: &str, args: &[impl Encode]) -> Result<Vec<u8>> {
    // Read the metadata file
    let metadata_content = fs::read_to_string(metadata_path)?;
    let metadata: InkProject = serde_json::from_str(&metadata_content)?;

    // Find the specified method in the metadata
    let message = metadata
        .spec()
        .messages()
        .iter()
        .find(|msg| msg.label() == method_name)
        .ok_or_else(|| anyhow!("Method `{}` not found in metadata", method_name))?;

    // Encode the selector
    let mut call_data = message.selector().to_bytes().to_vec();
    // Encode the arguments and append them to the selector
    for arg in args {
        call_data.extend(arg.encode());
    }

    Ok(call_data)
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new API client, configured to talk to Polkadot nodes.
    let api = OnlineClient::<PolkadotConfig>::from_url("ws://127.0.0.1:9944")
        .await?;

    let contract = "5CL8LNZQfrWwNt6Xmmb9pUWpXdNWatR94GTTqYq8oMMCbNDh";

 
    let metadata_path = "./artifacts/flipper.json"; // Replace with the actual path
    let method_name = "flip"; // The method to call
    let args: Vec<bool> = vec![]; // For example, `flip` takes no arguments

    // Generate the call data
    let call_data = generate_call_data(metadata_path, method_name, &args)?;

    println!("Encoded call data: 0x{}", hex::encode(call_data.clone()));

    let payload = polkadot::tx().contracts().call(
        subxt::utils::MultiAddress::Id(AccountId32::from_str(contract).unwrap()),
        0,
        Weight {
            ref_time: 242961830,
            proof_size: PROOF_SIZE,
        },
        None,
        call_data.clone(),
    );

    // Submit the balance transfer extrinsic from Alice, and wait for it to be successful
    // and in a finalized block. We get back the extrinsic events if all is well.
    let from = dev::alice();
    let events = api
    .tx()
    .sign_and_submit_then_watch_default(&payload, &from)
    .await?
    .wait_for_finalized_success()
    .await?;

    println!("{:?}", events);
    Ok(())
}