khodpay-signing

EVM transaction signing for BSC and other EVM-compatible chains.

Features

• EIP-1559 Transactions: Full support for Type 2 transactions with priority fees
• BIP-44 Integration: Sign transactions using keys derived from HD wallets
• BSC Support: Built-in chain IDs for BSC Mainnet (56) and Testnet (97)
• Security: Automatic zeroization of sensitive key material
• Type Safety: Strong types for Address, Wei, ChainId, and Signature

Quick Start

use khodpay_bip32::Network;
use khodpay_bip44::{CoinType, Purpose, Wallet};
use khodpay_signing::{
    Address, Bip44Signer, ChainId, Eip1559Transaction, 
    SignedTransaction, Wei, TRANSFER_GAS,
};

// 1. Create wallet from mnemonic
let mut wallet = Wallet::from_english_mnemonic(
    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
    "",
    Network::BitcoinMainnet,
).unwrap();

// 2. Get Ethereum account (CoinType 60 for EVM chains)
let account = wallet.get_account(Purpose::BIP44, CoinType::Ethereum, 0).unwrap();

// 3. Create signer
let signer = Bip44Signer::new(&account, 0).unwrap();
println!("Address: {}", signer.address());

// 4. Build transaction
let recipient: Address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e".parse().unwrap();

let tx = Eip1559Transaction::builder()
    .chain_id(ChainId::BscMainnet)
    .nonce(0)
    .max_priority_fee_per_gas(Wei::from_gwei(1))
    .max_fee_per_gas(Wei::from_gwei(5))
    .gas_limit(TRANSFER_GAS)
    .to(recipient)
    .value(Wei::from_ether(1))
    .build()
    .unwrap();

// 5. Sign transaction
let signature = signer.sign_transaction(&tx).unwrap();
let signed_tx = SignedTransaction::new(tx, signature);

// 6. Get raw transaction for broadcast
let raw_tx = signed_tx.to_raw_transaction();
println!("Raw TX: {}", raw_tx);
println!("TX Hash: {}", signed_tx.tx_hash_hex());

Types

ChainId

Network identifier for replay protection:

use khodpay_signing::ChainId;

let mainnet = ChainId::BscMainnet;  // 56
let testnet = ChainId::BscTestnet;  // 97
let custom = ChainId::Custom(1);    // Ethereum mainnet

Address

20-byte EVM address with EIP-55 checksum:

use khodpay_signing::Address;

// Parse from hex
let addr: Address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e".parse().unwrap();

// Display with checksum
println!("{}", addr);  // 0x742d35Cc6634C0532925a3b844Bc454e4438f44e

Wei

256-bit unsigned integer for Ether/BNB amounts:

use khodpay_signing::Wei;

let one_ether = Wei::from_ether(1);
let one_gwei = Wei::from_gwei(1);
let one_wei = Wei::from_wei(1u64);

// Arithmetic
let total = one_ether + one_gwei;

Eip1559Transaction

EIP-1559 (Type 2) transaction with builder pattern:

use khodpay_signing::{Eip1559Transaction, ChainId, Wei, TRANSFER_GAS};

let tx = Eip1559Transaction::builder()
    .chain_id(ChainId::BscMainnet)
    .nonce(0)
    .max_priority_fee_per_gas(Wei::from_gwei(1))  // Tip
    .max_fee_per_gas(Wei::from_gwei(5))           // Max total fee
    .gas_limit(TRANSFER_GAS)                       // 21,000 for transfers
    .to("0x...".parse().unwrap())
    .value(Wei::from_ether(1))
    .data(vec![])                                  // Optional calldata
    .build()
    .unwrap();

Bip44Signer

Signs transactions using BIP-44 derived keys:

use khodpay_signing::Bip44Signer;

// From BIP-44 account
let signer = Bip44Signer::new(&account, 0).unwrap();

// Or from raw private key (for testing)
let signer = Bip44Signer::from_private_key(&[1u8; 32]).unwrap();

let address = signer.address();
let signature = signer.sign_transaction(&tx).unwrap();

SignedTransaction

Signed transaction ready for broadcast:

use khodpay_signing::SignedTransaction;

let signed = SignedTransaction::new(tx, signature);

// For eth_sendRawTransaction
let raw = signed.to_raw_transaction();  // "0x02f86c..."

// Transaction hash
let hash = signed.tx_hash_hex();  // "0x..."

Gas Constants

use khodpay_signing::{TRANSFER_GAS, TOKEN_TRANSFER_GAS};

// Standard ETH/BNB transfer
assert_eq!(TRANSFER_GAS, 21_000);

// Typical BEP-20/ERC-20 token transfer
assert_eq!(TOKEN_TRANSFER_GAS, 65_000);

Security

• Private keys are wrapped in Zeroizing to ensure they're cleared from memory
• Signature implements Zeroize to clear r, s, v when dropped
• The underlying k256::SigningKey also implements Zeroize

Optional Features

serde

Enable serialization support:

[dependencies]
khodpay-signing = { version = "0.1", features = ["serde"] }

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE)
• MIT License (LICENSE-MIT)

at your option.