csv.go

package main

import (
	"bytes"
	"encoding/hex"
	"encoding/json"
	"log"
	"math/big"
	"strings"

	"git.ngx.fi/c0mm4nd/tronetl/tron"
	"golang.org/x/crypto/sha3"
)

// CsvTransaction represents a tron tx csv output, not trc10
// 1 TRX = 1000000 sun
type CsvTransaction struct {
	Hash             string `csv:"hash"`
	Nonce            string `csv:"nonce"`
	BlockHash        string `csv:"block_hash"`
	BlockNumber      uint64 `csv:"block_number"`
	TransactionIndex int    `csv:"transaction_index"`

	FromAddress          string `csv:"from_address"`
	ToAddress            string `csv:"to_address"`
	Value                string `csv:"value"`
	Gas                  string `csv:"gas"`
	GasPrice             string `csv:"gas_price"`
	Input                string `csv:"input"`
	Data                 string `csv:"data"` // raw_data.data (memo)
	BlockTimestamp       uint64 `csv:"block_timestamp"`
	MaxFeePerGas         string `csv:"max_fee_per_gas"`
	MaxPriorityFeePerGas string `csv:"max_priority_fee_per_gas"`
	TransactionType      string `csv:"transaction_type"`

	Status string

	// appendix
	TransactionTimestamp  int64 `csv:"transaction_timestamp"`
	TransactionExpiration int64 `csv:"transaction_expiration"`
	FeeLimit              int64 `csv:"fee_limit"`
}

// NewCsvTransaction creates a new CsvTransaction
func NewCsvTransaction(blockTimestamp uint64, txIndex int, jsontx *tron.JSONTransaction, httptx *tron.HTTPTransaction) *CsvTransaction {
	to := ""
	if jsontx.To != "" {
		to = tron.EnsureTAddr(jsontx.To[2:])
	}

	txType := "Unknown"
	if len(httptx.RawData.Contract) > 0 {
		txType = httptx.RawData.Contract[0].ContractType
	}

	status := ""
	if len(httptx.Ret) > 0 {
		status = httptx.Ret[0].ContractRet
	}

	return &CsvTransaction{
		Hash:                 jsontx.Hash[2:],
		Nonce:                "", //tx.Nonce,
		BlockHash:            jsontx.BlockHash[2:],
		BlockNumber:          uint64(*jsontx.BlockNumber),
		TransactionIndex:     txIndex,
		FromAddress:          tron.EnsureTAddr(jsontx.From[2:]),
		ToAddress:            to,
		Value:                jsontx.Value.ToInt().String(),
		Gas:                  jsontx.Gas.ToInt().String(),
		GasPrice:             jsontx.GasPrice.ToInt().String(), // https://support.ledger.com/hc/en-us/articles/6331588714141-How-do-Tron-TRX-fees-work-?support=true
		Input:                jsontx.Input[2:],
		Data:                 httptx.RawData.Data,
		BlockTimestamp:       blockTimestamp / 1000, // unit: sec
		MaxFeePerGas:         "",                    //tx.MaxFeePerGas.String(),
		MaxPriorityFeePerGas: "",                    //tx.MaxPriorityFeePerGas.String(),
		TransactionType:      txType,                //jsontx.Type[2:],

		Status: status, // can be SUCCESS REVERT

		// appendix
		TransactionTimestamp:  httptx.RawData.Timestamp / 1000,  // float64(httptx.RawData.Timestamp) * 1 / 1000,
		TransactionExpiration: httptx.RawData.Expiration / 1000, // float64(httptx.RawData.Expiration) * 1 / 1000,
		FeeLimit:              httptx.RawData.FeeLimit,
	}
}

// CsvBlock represents a tron block output
type CsvBlock struct {
	Number           uint64 `csv:"number"`
	Hash             string `csv:"hash"`
	ParentHash       string `csv:"parent_hash"`
	Nonce            string `csv:"nonce"`
	Sha3Uncles       string `csv:"sha3_uncles"`
	LogsBloom        string `csv:"logs_bloom"`
	TransactionsRoot string `csv:"transaction_root"`
	StateRoot        string `csv:"state_root"`
	ReceiptsRoot     string `csv:"receipts_root"`
	Miner            string `csv:"miner"`
	Difficulty       string `csv:"difficulty"`
	TotalDifficulty  string `csv:"total_difficulty"`
	Size             uint64 `csv:"size"`
	ExtraData        string `csv:"extra_data"`
	GasLimit         string `csv:"gas_limit"`
	GasUsed          string `csv:"gas_used"`
	Timestamp        uint64 `csv:"timestamp"`
	TansactionCount  int    `csv:"transaction_count"`
	BaseFeePerGas    string `csv:"base_fee_per_gas"`

	// append
	WitnessSignature string `csv:"witness_signature"`
}

// NewCsvBlock creates a new CsvBlock
func NewCsvBlock(jsonblock *tron.JSONBlockWithTxs, httpblock *tron.HTTPBlock) *CsvBlock {
	return &CsvBlock{
		Number:           uint64(*jsonblock.Number),
		Hash:             jsonblock.Hash[2:],
		ParentHash:       jsonblock.ParentHash[2:],
		Nonce:            "",
		Sha3Uncles:       "", // block.Sha3Uncles,
		LogsBloom:        jsonblock.LogsBloom[2:],
		TransactionsRoot: jsonblock.TransactionsRoot[2:],
		StateRoot:        jsonblock.StateRoot[2:],
		ReceiptsRoot:     "",                                    // block.ReceiptsRoot
		Miner:            tron.EnsureTAddr(jsonblock.Miner[2:]), // = WitnessAddress
		Difficulty:       "",
		TotalDifficulty:  "",
		Size:             uint64(*jsonblock.Size),
		ExtraData:        "",
		GasLimit:         jsonblock.GasLimit.ToInt().String(),
		GasUsed:          jsonblock.GasUsed.ToInt().String(),
		Timestamp:        uint64(httpblock.BlockHeader.RawData.Timestamp) / 1000,
		TansactionCount:  len(jsonblock.Transactions),
		BaseFeePerGas:    "", // block.BaseFeePerGas,

		//append
		WitnessSignature: httpblock.BlockHeader.WitnessSignature,
	}
}

// CsvTRC10Transfer is a trc10 transfer output
// https://developers.tron.network/docs/trc10-transfer-in-smart-contracts
// https://tronprotocol.github.io/documentation-en/mechanism-algorithm/system-contracts/
// It represents:
// - TransferContract
// - TransferAssetContract
type CsvTRC10Transfer struct {
	BlockNumber       uint64 `csv:"block_number"`
	BlockHash         string `csv:"block_hash"`
	TransactionHash   string `csv:"transaction_hash"`
	TransactionIndex  int    `csv:"transaction_index"`
	ContractCallIndex int    `csv:"contract_call_index"`

	AssetName   string `csv:"asset_name"` // do not omit => empty means trx
	FromAddress string `csv:"from_address"`
	ToAddress   string `csv:"to_address"`
	Value       string `csv:"value"`

	// TRX-like metadata
	Status                string `csv:"status"`
	TransactionTimestamp  int64  `csv:"transaction_timestamp"`
	TransactionExpiration int64  `csv:"transaction_expiration"`
	FeeLimit              int64  `csv:"fee_limit"`

	// Gas fields (from JSON transaction)
	Gas      string `csv:"gas"`
	GasPrice string `csv:"gas_price"`

	// Data (memo from raw_data.data)
	Data string `csv:"data"`
}

// NewCsvTRC10Transfer creates a new CsvTRC10Transfer
func NewCsvTRC10Transfer(blockHash string, blockNum uint64, txIndex, callIndex int, jsontx *tron.JSONTransaction, httpTx *tron.HTTPTransaction, tfParams *tron.TRC10TransferParams) *CsvTRC10Transfer {

	status := ""
	if len(httpTx.Ret) > 0 {
		status = httpTx.Ret[0].ContractRet
	}

	txnTs := httpTx.RawData.Timestamp / 1000
	txnExp := httpTx.RawData.Expiration / 1000
	feeLimit := httpTx.RawData.FeeLimit

	return &CsvTRC10Transfer{
		TransactionHash:   httpTx.TxID,
		BlockHash:         blockHash,
		BlockNumber:       blockNum,
		TransactionIndex:  txIndex,
		ContractCallIndex: callIndex,

		AssetName:   tfParams.AssetName,
		FromAddress: tron.EnsureTAddr(tfParams.OwnerAddress),
		ToAddress:   tron.EnsureTAddr(tfParams.ToAddress),
		Value:       tfParams.Amount.String(),

		// TRX-like metadata
		Status:                status,
		TransactionTimestamp:  txnTs,
		TransactionExpiration: txnExp,
		FeeLimit:              feeLimit,

		// Gas fields
		Gas:      jsontx.Gas.ToInt().String(),
		GasPrice: jsontx.GasPrice.ToInt().String(),

		// Data
		Data: httpTx.RawData.Data,
	}
}

// CsvLog is a EVM smart contract event log output
type CsvLog struct {
	BlockNumber     uint64 `csv:"block_number"`
	TransactionHash string `csv:"transaction_hash"`
	LogIndex        uint   `csv:"log_index"`

	Address string `csv:"address"`
	Topics  string `csv:"topics"`
	Data    string `csv:"data"`
}

// NewCsvLog creates a new CsvLog
func NewCsvLog(blockNumber uint64, txHash string, logIndex uint, log *tron.HTTPTxInfoLog) *CsvLog {
	return &CsvLog{
		BlockNumber:     blockNumber,
		TransactionHash: txHash,
		LogIndex:        logIndex,

		Address: tron.EnsureTAddr(log.Address),
		Topics:  strings.Join(log.Topics, ";"),
		Data:    log.Data,
	}
}

// CsvInternalTx is a EVM smart contract internal transaction
type CsvInternalTx struct {
	BlockNumber             uint64 `csv:"block_number"`
	TransactionHash         string `csv:"transaction_hash"`
	Index                   uint   `csv:"internal_index"`
	InternalTransactionHash string `csv:"internal_hash"`
	CallerAddress           string `csv:"caller_address"`
	TransferToAddress       string `csv:"transferTo_address"`
	CallInfoIndex           uint   `csv:"call_info_index"`
	CallTokenID             string `csv:"call_token_id"`
	CallValue               int64  `csv:"call_value"`
	Note                    string `csv:"note"`
	Rejected                bool   `csv:"rejected"`
}

// NewCsvInternalTx creates a new CsvInternalTx
func NewCsvInternalTx(blockNum uint64, txHash string, index uint, itx *tron.HTTPInternalTransaction, callInfoIndex uint, tokenID string, value int64) *CsvInternalTx {
	callerAddr := ""
	if itx.CallerAddress != "" {
		callerAddr = tron.EnsureTAddr(itx.CallerAddress)
	}

	transferToAddr := ""
	if itx.TransferToAddress != "" {
		transferToAddr = tron.EnsureTAddr(itx.TransferToAddress)
	}

	return &CsvInternalTx{
		BlockNumber:             blockNum,
		TransactionHash:         txHash,
		Index:                   index,
		InternalTransactionHash: itx.InternalTransactionHash,
		CallerAddress:           callerAddr,
		TransferToAddress:       transferToAddr,
		// CallValueInfo:     strings.Join(callValues, ";"),
		CallInfoIndex: callInfoIndex,
		CallTokenID:   tokenID,
		CallValue:     value,

		Note:     itx.Note,
		Rejected: itx.Rejected,
	}
}

// CsvReceipt is a receipt for tron transaction
type CsvReceipt struct {
	TxHash  string `csv:"transaction_hash"`
	TxIndex uint   `csv:"transaction_index"`
	// BlockHash         string `csv:"block_hash"` // cannot get this
	BlockNumber       uint64 `csv:"block_number"`
	ContractAddress   string `csv:"contract_address"`
	EnergyUsage       int64  `csv:"energy_usage,omitempty"`
	EnergyFee         int64  `csv:"energy_fee,omitempty"`
	OriginEnergyUsage int64  `csv:"origin_energy_usage,omitempty"`
	EnergyUsageTotal  int64  `csv:"energy_usage_total,omitempty"`
	NetUsage          int64  `csv:"net_usage,omitempty"`
	NetFee            int64  `csv:"net_fee,omitempty"`
	Result            string `csv:"result"`
}

func NewCsvReceipt(blockNum uint64, txHash string, txIndex uint, contractAddr string, r *tron.HTTPReceipt) *CsvReceipt {
	// contractAddr could be empty (normal transfers) or hex; keep output as T-addr when present
	if contractAddr != "" {
		contractAddr = tron.EnsureTAddr(contractAddr)
	}

	return &CsvReceipt{
		TxHash:  txHash,
		TxIndex: txIndex,
		// BlockHash:         blockHash,
		BlockNumber:       blockNum,
		ContractAddress:   contractAddr,
		EnergyUsage:       r.EnergyUsage,
		EnergyFee:         r.EnergyFee,
		OriginEnergyUsage: r.OriginEnergyUsage,
		EnergyUsageTotal:  r.EnergyUsageTotal,
		NetUsage:          r.NetUsage,
		NetFee:            r.NetFee,
		Result:            r.Result,
	}
}

// CsvAccount is a tron account
type CsvAccount struct {
	AccountName string `csv:"account_name"`
	Address     string `csv:"address"`
	Type        string `csv:"type"`
	CreateTime  int64  `csv:"create_time"`

	// DecodedName string `csv:decoded_name`
}

func NewCsvAccount(acc *tron.HTTPAccount) *CsvAccount {
	name, _ := hex.DecodeString(acc.AccountName)
	return &CsvAccount{
		AccountName: string(name),
		Address:     tron.EnsureTAddr(acc.Address),
		Type:        acc.AccountType,
		CreateTime:  acc.CreateTime / 1000,
	}
}

// CsvContract is a standard EVM contract
type CsvContract struct {
	Address           string `csv:"address"`
	Bytecode          string `csv:"bytecode"`
	FunctionSighashes string `csv:"function_sighashes"`
	IsErc20           bool   `csv:"is_erc20"`
	IsErc721          bool   `csv:"is_erc721"`
	IsErc1155         bool   `csv:"is_erc1155"`
	BlockNumber       uint64 `csv:"block_number"`

	// append some...
	ContractName               string
	ConsumeUserResourcePercent int
	OriginAddress              string
	OriginEnergyLimit          int64
}

func hashSignature(sig string) string {
	h := sha3.NewLegacyKeccak256()
	h.Write([]byte(sig))
	return hex.EncodeToString(h.Sum(nil))
}

func NewCsvContract(c *tron.HTTPContract) *CsvContract {
	hashes := make([]string, 0, len(c.Abi.Entrys))
	for _, abi := range c.Abi.Entrys {
		if strings.ToLower(abi.Type) == "function" {
			content := abi.Name + "("
			types := make([]string, 0, len(abi.Inputs))
			for _, input := range abi.Inputs {
				types = append(types, input.Type)
			}
			sig := content + strings.Join(types, ",") + ")"
			hashes = append(hashes, hashSignature(sig))
		}
	}

	isErc20 := implementsAnyOf(hashes, "totalSupply()") &&
		implementsAnyOf(hashes, "balanceOf(address)") &&
		implementsAnyOf(hashes, "transfer(address,uint256)") &&
		implementsAnyOf(hashes, "transferFrom(address,address,uint256)") &&
		implementsAnyOf(hashes, "approve(address,uint256)") &&
		implementsAnyOf(hashes, "allowance(address,address)")

	isErc721 := implementsAnyOf(hashes, "balanceOf(address)") &&
		implementsAnyOf(hashes, "ownerOf(uint256)") &&
		implementsAnyOf(hashes, "transfer(address,uint256)", "transferFrom(address,address,uint256)") &&
		implementsAnyOf(hashes, "approve(address,uint256)")

	isErc1155 := implementsAnyOf(hashes, "balanceOf(address,uint256)") &&
		implementsAnyOf(hashes, "balanceOfBatch(address[],uint256[])") &&
		implementsAnyOf(hashes, "safeTransferFrom(address,address,uint256,uint256,bytes)") &&
		implementsAnyOf(hashes, "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)") &&
		implementsAnyOf(hashes, "supportsInterface(bytes4)")

	return &CsvContract{
		Address:           tron.EnsureTAddr(c.ContractAddress),
		Bytecode:          c.Bytecode,
		FunctionSighashes: strings.Join(hashes, ";"),
		IsErc20:           isErc20,
		IsErc721:          isErc721,
		IsErc1155:         isErc1155,
		BlockNumber:       0,

		// append
		ContractName:               c.Name,
		ConsumeUserResourcePercent: c.ConsumeUserResourcePercent,
		OriginAddress:              tron.EnsureTAddr(c.OriginAddress),
		OriginEnergyLimit:          c.OriginEnergyLimit,
	}
}

func implementsAnyOf(hashes []string, sigStrs ...string) bool {
	for i := range sigStrs {
		hash := hashSignature(sigStrs[i])
		for j := range hashes {
			if hashes[j] == hash {
				return true
			}
		}
	}

	return false
}

// CsvTokens is a standard EVM contract token
type CsvTokens struct {
	Address     string `csv:"address"`
	Symbol      string `csv:"symbol"`
	Name        string `csv:"name"`
	Decimals    uint64 `csv:"decimals"`
	TotalSupply string `csv:"total_supply"`
	BlockNumber uint64 `csv:"block_number"`
}

func NewCsvTokens(cli *tron.TronClient, contract *tron.HTTPContract) *CsvTokens {
	contractAddr := contract.ContractAddress
	callerAddr := contract.OriginAddress
	if isLikelyProxyContractName(contract.Name) {
		// TransparentUpgradeableProxy blocks admin from fallback, avoid admin as caller
		callerAddr = contract.ContractAddress
	}

	symbolResult := fetchConstantResult(cli, contractAddr, callerAddr, "symbol()")
	symbol := ParseSymbol(symbolResult)
	if symbol == nil {
		log.Println("failed to parse symbol for contract", tron.EnsureHexAddr(contractAddr))
		logConstantResultDebug(symbolResult)
		return nil
	}

	nameResult := fetchConstantResult(cli, contractAddr, callerAddr, "name()")
	name := ParseName(nameResult)
	if name == nil {
		log.Println("failed to parse name for contract", tron.EnsureHexAddr(contractAddr))
		logConstantResultDebug(nameResult)
		return nil
	}

	decimalsResult := fetchConstantResult(cli, contractAddr, callerAddr, "decimals()")
	decimals := ParseDecimals(decimalsResult)
	if decimals == nil {
		log.Println("failed to parse decimals for contract", tron.EnsureHexAddr(contractAddr))
		logConstantResultDebug(decimalsResult)
		return nil
	}

	totalSupplyResult := fetchConstantResult(cli, contractAddr, callerAddr, "totalSupply()")
	totalSupply := ParseTotalSupply(totalSupplyResult)
	if totalSupply == nil {
		log.Println("failed to parse totalSupply for contract", tron.EnsureHexAddr(contractAddr))
		logConstantResultDebug(totalSupplyResult)
		return nil
	}

	block := cli.GetJSONBlockByNumberWithTxIDs(nil)

	return &CsvTokens{
		Address:     tron.EnsureTAddr(contractAddr),
		Symbol:      *symbol,
		Name:        *name,
		Decimals:    *decimals,
		TotalSupply: *totalSupply,
		BlockNumber: uint64(*block.Number),
	}
}

func fetchConstantResult(cli *tron.TronClient, contractAddr, callerAddr, funcSig string) []string {
	res := cli.CallContract(contractAddr, callerAddr, 0, 10000000, funcSig)
	if len(res.ConstantResult) > 0 {
		return res.ConstantResult
	}

	data := tron.FunctionSelector(funcSig)
	if hexResult, err := cli.EthCall(contractAddr, data); err == nil {
		trimmed := strings.TrimPrefix(hexResult, "0x")
		if trimmed != "" {
			return []string{trimmed}
		}
	}

	return nil
}

func logConstantResultDebug(results []string) {
	if len(results) == 0 {
		log.Println("constant_result: <empty>")
		return
	}
	payload, _ := json.Marshal(results)
	log.Println(string(payload))
}

func isLikelyProxyContractName(name string) bool {
	if name == "" {
		return false
	}
	return strings.Contains(strings.ToLower(name), "proxy")
}

func ParseSymbol(contractResults []string) *string {
	return parseAbiString(contractResults)
}

func ParseName(contractResults []string) *string {
	return parseAbiString(contractResults)
}

func parseAbiString(contractResults []string) *string {
	if len(contractResults) == 0 {
		return nil
	}

	result := strings.TrimPrefix(contractResults[0], "0x")
	if len(result) < 64 {
		return nil
	}

	if s, ok := parseDynamicAbiString(result); ok {
		return &s
	}

	if s, ok := parseBytes32String(result); ok {
		return &s
	}

	return nil
}

func parseDynamicAbiString(result string) (string, bool) {
	offsetBI, ok := new(big.Int).SetString(result[0:64], 16)
	if !ok {
		return "", false
	}
	offset := int(offsetBI.Int64())
	if offset < 0 || offset%32 != 0 {
		return "", false
	}
	offsetHex := offset * 2
	if len(result) < offsetHex+64 {
		return "", false
	}

	lenBI, ok := new(big.Int).SetString(result[offsetHex:offsetHex+64], 16)
	if !ok {
		return "", false
	}
	byteLen := int(lenBI.Int64())
	if byteLen < 0 {
		return "", false
	}
	dataStart := offsetHex + 64
	dataEnd := dataStart + byteLen*2
	if dataEnd > len(result) {
		return "", false
	}

	hexStr := result[dataStart:dataEnd]
	decoded, err := hex.DecodeString(hexStr)
	if err != nil {
		return "", false
	}

	return string(decoded), true
}

func parseBytes32String(result string) (string, bool) {
	if len(result) < 64 {
		return "", false
	}
	decoded, err := hex.DecodeString(result[:64])
	if err != nil {
		return "", false
	}
	decoded = bytes.TrimRight(decoded, "\x00")
	if len(decoded) == 0 {
		return "", false
	}

	return string(decoded), true
}

func ParseDecimals(contractResults []string) *uint64 {
	if len(contractResults) == 0 {
		return nil
	}

	result, ok := new(big.Int).SetString(contractResults[0], 16)
	if !ok {
		// TODO: err log here
		return nil
	}

	rtn := result.Uint64()
	return &rtn
}

func ParseTotalSupply(contractResults []string) *string {
	if len(contractResults) == 0 {
		return nil
	}

	result, ok := new(big.Int).SetString(contractResults[0], 16)
	if !ok {
		// TODO: err log here
		return nil
	}

	rtn := result.String()
	return &rtn
}

// CsvNewContract represents a newly created contract in the block range
type CsvNewContract struct {
	BlockNumber     uint64 `csv:"block_number"`
	TransactionHash string `csv:"transaction_hash"`
	ContractAddress string `csv:"contract_address"`
	Method          string `csv:"method"` // "transaction" or "internal_transaction"
}

// NewCsvNewContract creates a new CsvNewContract
func NewCsvNewContract(blockNum uint64, txHash string, contractAddr string, method string) *CsvNewContract {
	return &CsvNewContract{
		BlockNumber:     blockNum,
		TransactionHash: txHash,
		ContractAddress: tron.EnsureTAddr(contractAddr),
		Method:          method,
	}
}