func (self *XEth) AllLogs(earliest, latest int64, skip, max int, address []string, topics [][]string) vm.Logs {
filter := filters.New(self.backend.ChainDb())
filter.SetBeginBlock(earliest)
filter.SetEndBlock(latest)
filter.SetAddresses(cAddress(address))
filter.SetTopics(cTopics(topics))
return filter.Find()
}
// Start Go API. Not important for this version
func (c *Contract) Subscribe(key *ecdsa.PrivateKey, serviceId *big.Int, amount, price *big.Int, cb func(*Subscription)) (*types.Transaction, error) {
from := crypto.PubkeyToAddress(key.PublicKey)
data, err := c.abi.Pack("subscribe", serviceId)
if err != nil {
return nil, err
}
statedb, err := c.blockchain.State()
if err != nil {
return nil, err
}
transaction, err := types.NewTransaction(statedb.GetNonce(from), contractAddress, amount, big.NewInt(600000), big.NewInt(50000000000), data).SignECDSA(key)
if err != nil {
return nil, err
}
evId := c.abi.Events["NewSubscription"].Id()
filter := filters.New(c.db)
filter.SetAddresses([]common.Address{contractAddress})
filter.SetTopics([][]common.Hash{ // TODO refactor, helper
[]common.Hash{evId},
[]common.Hash{from.Hash()},
[]common.Hash{common.BigToHash(serviceId)},
})
filter.SetBeginBlock(0)
filter.SetEndBlock(-1)
filter.LogCallback = func(log *vm.Log, removed bool) {
// TODO: do to and from validation here
/*
from := log.Topics[1]
to := log.Topics[2]
*/
subscriptionId := common.BytesToHash(log.Data[0:31])
nonce := common.BytesToBig(log.Data[31:])
c.channelMu.Lock()
defer c.channelMu.Unlock()
channel, exist := c.subs[subscriptionId]
if !exist {
channel = NewSubscription(c, subscriptionId, from, serviceId, nonce)
c.subs[subscriptionId] = channel
}
cb(channel)
}
c.filters.Add(filter, filters.PendingLogFilter)
return transaction, nil
}
func (self *XEth) NewBlockFilter() int {
self.blockMu.Lock()
defer self.blockMu.Unlock()
filter := filters.New(self.backend.ChainDb())
id := self.filterManager.Add(filter)
self.blockQueue[id] = &hashQueue{timeout: time.Now()}
filter.BlockCallback = func(block *types.Block, logs vm.Logs) {
self.blockMu.Lock()
defer self.blockMu.Unlock()
if queue := self.blockQueue[id]; queue != nil {
queue.add(block.Hash())
}
}
return id
}
func (self *XEth) NewTransactionFilter() int {
self.transactionMu.Lock()
defer self.transactionMu.Unlock()
filter := filters.New(self.backend.ChainDb())
id := self.filterManager.Add(filter)
self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
filter.TransactionCallback = func(tx *types.Transaction) {
self.transactionMu.Lock()
defer self.transactionMu.Unlock()
if queue := self.transactionQueue[id]; queue != nil {
queue.add(tx.Hash())
}
}
return id
}
func (self *XEth) NewLogFilter(earliest, latest int64, skip, max int, address []string, topics [][]string) int {
self.logMu.Lock()
defer self.logMu.Unlock()
filter := filters.New(self.backend.ChainDb())
id := self.filterManager.Add(filter)
self.logQueue[id] = &logQueue{timeout: time.Now()}
filter.SetBeginBlock(earliest)
filter.SetEndBlock(latest)
filter.SetAddresses(cAddress(address))
filter.SetTopics(cTopics(topics))
filter.LogsCallback = func(logs vm.Logs) {
self.logMu.Lock()
defer self.logMu.Unlock()
if queue := self.logQueue[id]; queue != nil {
queue.add(logs...)
}
}
return id
}