[WIP/Don't merge]: Feat/send tx endpoint

[21e8]

[21e8]

@HardhatChad this isn't working, could you have a look and guess why?

[asktree]

are you getting Blockhash Not Found?

[21e8]

@asktree nope, 404

[authrequest]

https://jito-labs.gitbook.io/mev/searcher-resources/block-engine/mainnet-addresses

[crypt0miester]

ser, it is failing because jito does not have node version endpoint.

use a modified send_transaction_with_config() like below. also you will need to tip jito otherwise your txns won't land.

do note that I tried this and and it was not economical. jito tips are at around 500k-1M lamports and that also sometimes fails.

/// you will need to add more "use" and install base64 lib
use base64::Engine;

fn serialize_and_encode<T>(input: &T, encoding: UiTransactionEncoding) -> ClientResult<String>
where
    T: serde::ser::Serialize,
{
    let serialized = serialize(input)
        .map_err(|e| ClientErrorKind::Custom(format!("Serialization failed: {e}")))?;
    let encoded = match encoding {
        UiTransactionEncoding::Base58 => bs58::encode(serialized).into_string(),
        UiTransactionEncoding::Base64 => base64::prelude::BASE64_STANDARD.encode(serialized),
        _ => {
            return Err(ClientErrorKind::Custom(format!(
                "unsupported encoding: {encoding}. Supported encodings: base58, base64"
            ))
            .into())
        }
    };
    Ok(encoded)
}


async fn send_transaction_with_config(
    client: &RpcClient,
    transaction: &impl SerializableTransaction,
    config: RpcSendTransactionConfig,
) -> ClientResult<Signature> {
    let encoding = if let Some(encoding) = config.encoding {
        encoding
    } else {
        UiTransactionEncoding::Base64
    };
    let preflight_commitment = CommitmentConfig {
        commitment: config.preflight_commitment.unwrap_or_default(),
    };

    let config = RpcSendTransactionConfig {
        encoding: Some(encoding),
        preflight_commitment: Some(preflight_commitment.commitment),
        ..config
    };
    let serialized_encoded = serialize_and_encode(transaction, encoding)?;
    let signature_base58_str: String = match client
        .send(
            RpcRequest::SendTransaction,
            json!([serialized_encoded, config]),
        )
        .await
    {
        Ok(signature_base58_str) => signature_base58_str,
        Err(err) => {
            if let ClientErrorKind::RpcError(RpcError::RpcResponseError {
                code,
                message,
                data,
            }) = &err.kind
            {
                println!("{} {}", code, message);
                if let RpcResponseErrorData::SendTransactionPreflightFailure(
                    RpcSimulateTransactionResult {
                        logs: Some(logs), ..
                    },
                ) = data
                {
                    for (i, log) in logs.iter().enumerate() {
                        println!("{:>3}: {}", i + 1, log);
                    }
                    println!("");
                }
            }
            return Err(err);
        }
    };

    let signature = signature_base58_str
        .parse::<Signature>()
        .map_err(|err| Into::<ClientError>::into(RpcError::ParseError(err.to_string())))?;
    if signature != *transaction.get_signature() {
        Err(RpcError::RpcRequestError(format!(
            "RPC node returned mismatched signature {:?}, expected {:?}",
            signature,
            transaction.get_signature()
        ))
        .into())
    } else {
        Ok(*transaction.get_signature())
    }
}

[ArjixWasTaken]

[WIP/Don't merge]

https://github.blog/2019-02-14-introducing-draft-pull-requests/