// Start the miner with the given number of threads func (s *PrivateMinerAPI) Start(threads rpc.HexNumber) (bool, error) { s.e.StartAutoDAG() err := s.e.StartMining(threads.Int(), "") if err == nil { return true, nil } return false, err }
// UninstallFilter disables and removes an existing filter. func (s *PublicWhisperAPI) UninstallFilter(filterId rpc.HexNumber) bool { s.messagesMu.Lock() defer s.messagesMu.Unlock() if _, ok := s.messages[filterId.Int()]; ok { delete(s.messages, filterId.Int()) return true } return false }
// GetFilterChanges retrieves all the new messages matched by a filter since the last retrieval. func (s *PublicWhisperAPI) GetFilterChanges(filterId rpc.HexNumber) []WhisperMessage { s.messagesMu.RLock() defer s.messagesMu.RUnlock() if s.messages[filterId.Int()] != nil { if changes := s.messages[filterId.Int()].retrieve(); changes != nil { return changes } } return returnWhisperMessages(nil) }
// GetMessages retrieves all the known messages that match a specific filter. func (s *PublicWhisperAPI) GetMessages(filterId rpc.HexNumber) []WhisperMessage { // Retrieve all the cached messages matching a specific, existing filter s.messagesMu.RLock() defer s.messagesMu.RUnlock() var messages []*Message if s.messages[filterId.Int()] != nil { messages = s.messages[filterId.Int()].messages() } return returnWhisperMessages(messages) }
// GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true // all transactions in the block are returned in full detail, otherwise only the transaction hash is returned. func (s *PublicBlockChainAPI) GetUncleByBlockHashAndIndex(blockHash common.Hash, index rpc.HexNumber) (map[string]interface{}, error) { if block := s.bc.GetBlock(blockHash); block != nil { uncles := block.Uncles() if index.Int() < 0 || index.Int() >= len(uncles) { glog.V(logger.Debug).Infof("uncle block on index %d not found for block %s", index.Int(), blockHash.Hex()) return nil, nil } block = types.NewBlockWithHeader(uncles[index.Int()]) return s.rpcOutputBlock(block, false, false) } return nil, nil }
// GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index. When fullTx is true // all transactions in the block are returned in full detail, otherwise only the transaction hash is returned. func (s *PublicBlockChainAPI) GetUncleByBlockNumberAndIndex(blockNr rpc.BlockNumber, index rpc.HexNumber) (map[string]interface{}, error) { if blockNr == rpc.PendingBlockNumber { return nil, nil } if block := blockByNumber(s.miner, s.bc, blockNr); block != nil { uncles := block.Uncles() if index.Int() < 0 || index.Int() >= len(uncles) { glog.V(logger.Debug).Infof("uncle block on index %d not found for block #%d", index.Int(), blockNr) return nil, nil } block = types.NewBlockWithHeader(uncles[index.Int()]) return s.rpcOutputBlock(block, false, false) } return nil, nil }
// Resend accepts an existing transaction and a new gas price and limit. It will remove the given transaction from the // pool and reinsert it with the new gas price and limit. func (s *PublicTransactionPoolAPI) Resend(tx *Tx, gasPrice, gasLimit *rpc.HexNumber) (common.Hash, error) { pending := s.txPool.GetTransactions() for _, p := range pending { if pFrom, err := p.From(); err == nil && pFrom == tx.From && p.SigHash() == tx.tx.SigHash() { if gasPrice == nil { gasPrice = rpc.NewHexNumber(tx.tx.GasPrice()) } if gasLimit == nil { gasLimit = rpc.NewHexNumber(tx.tx.Gas()) } var newTx *types.Transaction contractCreation := (*tx.tx.To() == common.Address{}) if contractCreation { newTx = types.NewContractCreation(tx.tx.Nonce(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data()) } else { newTx = types.NewTransaction(tx.tx.Nonce(), *tx.tx.To(), tx.tx.Value(), gasPrice.BigInt(), gasLimit.BigInt(), tx.tx.Data()) } signedTx, err := s.sign(tx.From, newTx) if err != nil { return common.Hash{}, err } s.txPool.RemoveTx(tx.Hash) if err = s.txPool.Add(signedTx); err != nil { return common.Hash{}, err } return signedTx.Hash(), nil } } return common.Hash{}, fmt.Errorf("Transaction %#x not found", tx.Hash) }
// SubmitHashrate can be used for remote miners to submit their hash rate. This enables the node to report the combined // hash rate of all miners which submit work through this node. It accepts the miner hash rate and an identifier which // must be unique between nodes. func (s *PublicMinerAPI) SubmitHashrate(hashrate rpc.HexNumber, id common.Hash) bool { s.agent.SubmitHashrate(id, hashrate.Uint64()) return true }
// SubmitWork can be used by external miner to submit their POW solution. It returns an indication if the work was // accepted. Note, this is not an indication if the provided work was valid! func (s *PublicMinerAPI) SubmitWork(nonce rpc.HexNumber, solution, digest common.Hash) bool { return s.agent.SubmitWork(nonce.Uint64(), digest, solution) }
// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index. func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(blockHash common.Hash, index rpc.HexNumber) (*RPCTransaction, error) { if block := s.bc.GetBlock(blockHash); block != nil { return newRPCTransactionFromBlockIndex(block, index.Int()) } return nil, nil }
// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index. func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(blockNr rpc.BlockNumber, index rpc.HexNumber) (*RPCTransaction, error) { if block := blockByNumber(s.miner, s.bc, blockNr); block != nil { return newRPCTransactionFromBlockIndex(block, index.Int()) } return nil, nil }