transaction.hpp

Go to the documentation of this file.

#pragma once
 
#include <secp256k1_recovery.h>
 
extern "C" {
  #include <KeccakSponge.h>
}
 
#include "config.hpp"
#include "utils.hpp"
#include "rlp.hpp"
 
class Transaction {
  public:
 
  static inline constexpr std::size_t FieldsCount = 9;
 
  enum Field { 
    Nonce, GasPrice, GasLimit, To, Value, Data, V, R, S,
  };
 
  private:
 
  enum FieldType {
    DATA, QUANTITY,
  };
 
  static inline constexpr FieldType fieldTypeMapping[FieldsCount] = { QUANTITY, QUANTITY, QUANTITY, DATA, QUANTITY, DATA, QUANTITY, QUANTITY, QUANTITY };
 
  secp256k1_context *secp256k1Context;
 
  Utils::Byte nonce[Config::Size::TransactionQuantityBuffer];
  Utils::Byte gasPrice[Config::Size::TransactionQuantityBuffer];
  Utils::Byte gasLimit[Config::Size::TransactionQuantityBuffer];
  Utils::Byte to[Config::Size::TransactionAddressBuffer];
  Utils::Byte value[Config::Size::TransactionQuantityBuffer];
  Utils::Byte data[Config::Size::TransactionDataBuffer];
  Utils::Byte v[Config::Size::TransactionQuantityBuffer];
  Utils::Byte r[Config::Size::TransactionQuantityBuffer];
  Utils::Byte s[Config::Size::TransactionQuantityBuffer];
 
  RLP::Item rlpInput[FieldsCount] = {
    { .buffer = nonce, .length = 0 },
    { .buffer = gasPrice, .length = 0 },
    { .buffer = gasLimit, .length = 0 },
    { .buffer = to, .length = 0 },
    { .buffer = value, .length = 0 },
    { .buffer = data, .length = 0 },
    { .buffer = v, .length = 0 },
    { .buffer = r, .length = 0 },
    { .buffer = s, .length = 0 },
  };
 
  inline std::size_t _keccak256(Utils::Buffer input, std::size_t inputLength, Utils::Buffer hash) {
    KeccakWidth1600_Sponge(1088, 512, input, inputLength, 0x01, hash, 32);
    return 32;
  }
  
  inline std::size_t _ecdsa(Utils::Buffer hash, Utils::Buffer privateKey, Utils::Buffer signature, int *recid) {
    secp256k1_ecdsa_recoverable_signature ecdsaSig;
    secp256k1_ecdsa_sign_recoverable(secp256k1Context, &ecdsaSig, hash, privateKey, secp256k1_nonce_function_rfc6979, NULL);
    secp256k1_ecdsa_recoverable_signature_serialize_compact(secp256k1Context, signature, recid, &ecdsaSig);
    return 64;
  }
 
  public:
 
  Transaction() {
    secp256k1Context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
  }
 
  ~Transaction() {
    secp256k1_context_destroy(secp256k1Context);
  }
 
  void setField(Field field, const char *value) {
    rlpInput[field].length = Utils::hexStringToBuffer(
      value, 
      rlpInput[field].buffer, 
      fieldTypeMapping[field] == FieldType::QUANTITY
    );
  }
 
  void setField(Field field, Buffer value, std::size_t size) {
    // Trim leading zero bytes if of type Quantity
    if(fieldTypeMapping[field] == FieldType::QUANTITY) {
      while(*value == 0 && size > 0) {
        ++value;
        --size;
      }
    }
 
    rlpInput[field].length = size;
    memcpy(rlpInput[field].buffer, value, size);
  }
 
  std::size_t sign(const char *privateKey, Utils::Buffer transaction) {
    Utils::Byte privateKeyBuffer[32];
    Utils::hexStringToBuffer(privateKey, 64, privateKeyBuffer);
    return sign(privateKeyBuffer, transaction);
  }
 
  std::size_t sign(Utils::Buffer privateKey, Utils::Buffer transaction) {
    // Inject Chain ID as v
    rlpInput[Field::V].buffer[0] = 0x01;
    rlpInput[Field::V].length = 1;
 
    // Reset signature
    rlpInput[Field::R].length = 0;
    rlpInput[Field::S].length = 0;
 
    // Encode transaction
    std::size_t transactionLength = RLP::encodeList(rlpInput, FieldsCount, transaction);
 
    // Get transaction hash
    Utils::Byte hash[32];
    _keccak256(transaction, transactionLength, hash);
 
    // Get transaction signature
    Utils::Byte signature[64];
    int recid;
    _ecdsa(hash, privateKey, signature, &recid);
 
    // Inject signature
    rlpInput[Field::V].buffer[0] = recid + 37;
    setField(Field::R, signature, 32);
    setField(Field::S, signature + 32, 32);
 
    // Encode signed transaction and return buffer length
    return RLP::encodeList(rlpInput, FieldsCount, transaction);
  }
};