129 lines
4.0 KiB
Go
129 lines
4.0 KiB
Go
package bchain
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/golang/glog"
|
|
)
|
|
|
|
// MempoolEthereumType is mempool handle of EthereumType chains
|
|
type MempoolEthereumType struct {
|
|
chain BlockChain
|
|
mux sync.Mutex
|
|
txToInputOutput map[string][]addrIndex
|
|
addrDescToTx map[string][]Outpoint
|
|
}
|
|
|
|
// NewMempoolEthereumType creates new mempool handler.
|
|
func NewMempoolEthereumType(chain BlockChain) *MempoolEthereumType {
|
|
return &MempoolEthereumType{chain: chain}
|
|
}
|
|
|
|
// GetTransactions returns slice of mempool transactions for given address
|
|
func (m *MempoolEthereumType) GetTransactions(address string) ([]Outpoint, error) {
|
|
parser := m.chain.GetChainParser()
|
|
addrDesc, err := parser.GetAddrDescFromAddress(address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return m.GetAddrDescTransactions(addrDesc)
|
|
}
|
|
|
|
// GetAddrDescTransactions returns slice of mempool transactions for given address descriptor
|
|
func (m *MempoolEthereumType) GetAddrDescTransactions(addrDesc AddressDescriptor) ([]Outpoint, error) {
|
|
m.mux.Lock()
|
|
defer m.mux.Unlock()
|
|
return append([]Outpoint(nil), m.addrDescToTx[string(addrDesc)]...), nil
|
|
}
|
|
|
|
func (m *MempoolEthereumType) updateMappings(newTxToInputOutput map[string][]addrIndex, newAddrDescToTx map[string][]Outpoint) {
|
|
m.mux.Lock()
|
|
defer m.mux.Unlock()
|
|
m.txToInputOutput = newTxToInputOutput
|
|
m.addrDescToTx = newAddrDescToTx
|
|
}
|
|
|
|
func appendAddress(io []addrIndex, i int32, a string, parser BlockChainParser) []addrIndex {
|
|
if len(a) > 0 {
|
|
addrDesc, err := parser.GetAddrDescFromAddress(a)
|
|
if err != nil {
|
|
glog.Error("error in input addrDesc in ", a, ": ", err)
|
|
return io
|
|
}
|
|
io = append(io, addrIndex{string(addrDesc), i})
|
|
}
|
|
return io
|
|
}
|
|
|
|
// Resync gets mempool transactions and maps outputs to transactions.
|
|
// Resync is not reentrant, it should be called from a single thread.
|
|
// Read operations (GetTransactions) are safe.
|
|
func (m *MempoolEthereumType) Resync(onNewTxAddr OnNewTxAddrFunc) (int, error) {
|
|
start := time.Now()
|
|
glog.V(1).Info("Mempool: resync")
|
|
txs, err := m.chain.GetMempoolTransactions()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
parser := m.chain.GetChainParser()
|
|
// allocate slightly larger capacity of the maps
|
|
newTxToInputOutput := make(map[string][]addrIndex, len(m.txToInputOutput)+5)
|
|
newAddrDescToTx := make(map[string][]Outpoint, len(m.addrDescToTx)+5)
|
|
for _, txid := range txs {
|
|
io, exists := m.txToInputOutput[txid]
|
|
if !exists {
|
|
tx, err := m.chain.GetTransactionForMempool(txid)
|
|
if err != nil {
|
|
if err != ErrTxNotFound {
|
|
glog.Warning("cannot get transaction ", txid, ": ", err)
|
|
}
|
|
continue
|
|
}
|
|
io = make([]addrIndex, 0, len(tx.Vout)+len(tx.Vin))
|
|
for _, output := range tx.Vout {
|
|
addrDesc, err := parser.GetAddrDescFromVout(&output)
|
|
if err != nil {
|
|
if err != ErrAddressMissing {
|
|
glog.Error("error in output addrDesc in ", txid, " ", output.N, ": ", err)
|
|
}
|
|
continue
|
|
}
|
|
if len(addrDesc) > 0 {
|
|
io = append(io, addrIndex{string(addrDesc), int32(output.N)})
|
|
}
|
|
}
|
|
for _, input := range tx.Vin {
|
|
for i, a := range input.Addresses {
|
|
appendAddress(io, ^int32(i), a, parser)
|
|
}
|
|
}
|
|
t, err := parser.EthereumTypeGetErc20FromTx(tx)
|
|
if err != nil {
|
|
glog.Error("GetErc20FromTx for tx ", txid, ", ", err)
|
|
} else {
|
|
for i := range t {
|
|
io = appendAddress(io, ^int32(i+1), t[i].From, parser)
|
|
io = appendAddress(io, int32(i+1), t[i].To, parser)
|
|
}
|
|
}
|
|
if onNewTxAddr != nil {
|
|
sent := make(map[string]struct{})
|
|
for _, si := range io {
|
|
if _, found := sent[si.addrDesc]; !found {
|
|
onNewTxAddr(tx, AddressDescriptor(si.addrDesc))
|
|
sent[si.addrDesc] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
newTxToInputOutput[txid] = io
|
|
for _, si := range io {
|
|
newAddrDescToTx[si.addrDesc] = append(newAddrDescToTx[si.addrDesc], Outpoint{txid, si.n})
|
|
}
|
|
}
|
|
m.updateMappings(newTxToInputOutput, newAddrDescToTx)
|
|
glog.Info("Mempool: resync finished in ", time.Since(start), ", ", len(m.txToInputOutput), " transactions in mempool")
|
|
return len(m.txToInputOutput), nil
|
|
}
|