Revelium.Evm 0.0.2

Revelium.Evm

Revelium.Evm is .NET standard 2.1 integration library for EVM-compatible networks, aimed primarily at creating transaction-intensive applications (trading bots, etc.).

In addition to the basic capabilities of creating, signing and sending EVM transactions (including EIP-1559), the library also contains:

• NonceManager to effective offline Nonce management and send transactions without waiting for confirmations;
• RpcCallSequencer to manage the queue of sent transactions. If the Rpc has a limit on the number of transactions from one address, the class allows you to not exceed the limits, streamline sending, and allows you to cancel queued calls that have not yet been sent to the Rpc;
• RpcClient with built-in support for limiting the number of requests per unit of time and requests retries in case of errors with support for various strategies;
• BlockScoutApi for BlockScout explorer.

Getting started

Installation

PM> Install-Package Revelium.Evm

Create, sign and send transaction (short way)

Let's create new wallet and signer:

var key = EthECKey.GenerateKey();
var signer = new EthEcdsaSigner(key);
var fromAddress = signer.GetAddress();

To interact with the Etherlink test network, let's create an rpc client:

var rpc = new RpcClient(url: RpcUrl.ETHERLINK_GHOSTNET);

Now we are ready to create and send the transaction:

var tx = new TransactionLegacyRequest
{
    From = fromAddress,
    To = "<TOKEN_CONTRACT_ADDRESS>",
    GasPrice = 100_000_000,
    Data = new Approve
    {
        Spender = "<SPENDER_ADDRESS>",
        Value = 1_000_000_000_000
    }.CreateTransactionInput("<TOKEN_CONTRACT_ADDRESS>").Data
};

var (txId, error) = await rpc.SignAndSendLegacyTransactionAsync(
    tx: tx,
    signer: signer,
    estimateGas: true,
    cancellationToken: cancellationToken);

And finally, as an example, we will receive the submitted transaction via the BlockScout API:

var api = new BlockScoutApi(BlockScoutApi.ETHERLINK_TESTNET);
var tx = await api.GetTransactionAsync(txId);

Create, sign and send transaction (long detailed way)

Let's look at a more detailed and low-level transaction creation:

First of all, we need a transaction counter for the nonce. To do this, we will use the nonce manager, which allows you to send transactions without waiting for confirmation of previous ones:

var (nonce, nonceError) = await NonceManager
    .GetOrAddInstance(fromAddress)
    .GetNonceAsync(
        rpc: rpc,
        pending: true);

if (nonceError != null) { /* do something if necessary */ }

Let's create an Approve transaction for the Erc20 token:

var approve = new Approve
{
    FromAddress = fromAddress,
    GasPrice = 100_000_000,
    Gas = 1_000_000,
    Nonce = nonce,
    Spender = "<SPENDER_ADDRESS>",
    Value = 1_000_000_000_000

}.CreateTransactionInput("<TOKEN_CONTRACT_ADDRESS>");

We can also estimate gas usage:

var (estimatedGas, estimateGasError) = await rpc.EstimateGasAsync(
    block: BlockNumber.Latest,
    to: approve.To,
    from: approve.From,
    gasPrice: approve.GasPrice,
    value: 0,
    data: approve.Data);

if (estimateGasError == null)
    approve.Gas = new HexBigInteger(estimatedGas);

Everything is ready to sign the transaction, verify and send:

var request = new TransactionLegacyRequest(approve);

signer.Sign(request);

if (!request.Verify()) { /* do something if necessary */ }

var (txId, error) = await rpc.SendRawTransactionAsync(request);