aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--accounts/account_manager.go16
-rw-r--r--accounts/accounts_test.go28
-rw-r--r--cmd/geth/js.go2
-rw-r--r--eth/api.go180
-rw-r--r--eth/backend.go4
-rw-r--r--internal/web3ext/web3ext.go6
6 files changed, 165 insertions, 71 deletions
diff --git a/accounts/account_manager.go b/accounts/account_manager.go
index 3afadf6b2..bfb7556d6 100644
--- a/accounts/account_manager.go
+++ b/accounts/account_manager.go
@@ -147,9 +147,21 @@ func (am *Manager) Sign(addr common.Address, hash []byte) (signature []byte, err
return crypto.Sign(hash, unlockedKey.PrivateKey)
}
+// SignWithPassphrase signs hash if the private key matching the given address can be
+// decrypted with the given passphrase.
+func (am *Manager) SignWithPassphrase(addr common.Address, passphrase string, hash []byte) (signature []byte, err error) {
+ _, key, err := am.getDecryptedKey(Account{Address: addr}, passphrase)
+ if err != nil {
+ return nil, err
+ }
+
+ defer zeroKey(key.PrivateKey)
+ return crypto.Sign(hash, key.PrivateKey)
+}
+
// Unlock unlocks the given account indefinitely.
-func (am *Manager) Unlock(a Account, keyAuth string) error {
- return am.TimedUnlock(a, keyAuth, 0)
+func (am *Manager) Unlock(a Account, passphrase string) error {
+ return am.TimedUnlock(a, passphrase, 0)
}
// Lock removes the private key with the given address from memory.
diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go
index 829cf3968..2e5f2b44a 100644
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@@ -81,6 +81,34 @@ func TestSign(t *testing.T) {
}
}
+func TestSignWithPassphrase(t *testing.T) {
+ dir, am := tmpManager(t, true)
+ defer os.RemoveAll(dir)
+
+ pass := "passwd"
+ acc, err := am.NewAccount(pass)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, unlocked := am.unlocked[acc.Address]; unlocked {
+ t.Fatal("expected account to be locked")
+ }
+
+ _, err = am.SignWithPassphrase(acc.Address, pass, testSigData)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, unlocked := am.unlocked[acc.Address]; unlocked {
+ t.Fatal("expected account to be locked")
+ }
+
+ if _, err = am.SignWithPassphrase(acc.Address, "invalid passwd", testSigData); err == nil {
+ t.Fatal("expected SignHash to fail with invalid password")
+ }
+}
+
func TestTimedUnlock(t *testing.T) {
dir, am := tmpManager(t, true)
defer os.RemoveAll(dir)
diff --git a/cmd/geth/js.go b/cmd/geth/js.go
index 026e5570d..5f455d7a3 100644
--- a/cmd/geth/js.go
+++ b/cmd/geth/js.go
@@ -41,7 +41,7 @@ import (
)
var (
- passwordRegexp = regexp.MustCompile("personal.[nu]")
+ passwordRegexp = regexp.MustCompile("personal.[nus]")
onlyws = regexp.MustCompile("^\\s*$")
exit = regexp.MustCompile("^\\s*exit\\s*;*\\s*$")
)
diff --git a/eth/api.go b/eth/api.go
index c8ccbd51b..06f4d5de0 100644
--- a/eth/api.go
+++ b/eth/api.go
@@ -148,7 +148,7 @@ func (s *PublicEthereumAPI) Etherbase() (common.Address, error) {
return s.e.Etherbase()
}
-// see Etherbase
+// Coinbase is the address that mining rewards will be send to (alias for Etherbase)
func (s *PublicEthereumAPI) Coinbase() (common.Address, error) {
return s.Etherbase()
}
@@ -217,18 +217,17 @@ func (s *PublicMinerAPI) SubmitWork(nonce rpc.HexNumber, solution, digest common
// result[0], 32 bytes hex encoded current block header pow-hash
// result[1], 32 bytes hex encoded seed hash used for DAG
// result[2], 32 bytes hex encoded boundary condition ("target"), 2^256/difficulty
-func (s *PublicMinerAPI) GetWork() ([]string, error) {
+func (s *PublicMinerAPI) GetWork() (work [3]string, err error) {
if !s.e.IsMining() {
if err := s.e.StartMining(0, ""); err != nil {
- return nil, err
+ return work, err
}
}
- if work, err := s.agent.GetWork(); err == nil {
- return work[:], nil
- } else {
- glog.Infof("%v\n", err)
+ if work, err = s.agent.GetWork(); err == nil {
+ return
}
- return nil, fmt.Errorf("mining not ready")
+ glog.V(logger.Debug).Infof("%v", err)
+ return work, fmt.Errorf("mining not ready")
}
// SubmitHashrate can be used for remote miners to submit their hash rate. This enables the node to report the combined
@@ -423,14 +422,23 @@ func (s *PublicAccountAPI) Accounts() []accounts.Account {
}
// PrivateAccountAPI provides an API to access accounts managed by this node.
-// It offers methods to create, (un)lock en list accounts.
+// It offers methods to create, (un)lock en list accounts. Some methods accept
+// passwords and are therefore considered private by default.
type PrivateAccountAPI struct {
- am *accounts.Manager
+ am *accounts.Manager
+ txPool *core.TxPool
+ txMu *sync.Mutex
+ gpo *GasPriceOracle
}
// NewPrivateAccountAPI create a new PrivateAccountAPI.
-func NewPrivateAccountAPI(am *accounts.Manager) *PrivateAccountAPI {
- return &PrivateAccountAPI{am}
+func NewPrivateAccountAPI(e *Ethereum) *PrivateAccountAPI {
+ return &PrivateAccountAPI{
+ am: e.accountManager,
+ txPool: e.txPool,
+ txMu: &e.txMu,
+ gpo: e.gpo,
+ }
}
// ListAccounts will return a list of addresses for accounts this node manages.
@@ -452,6 +460,8 @@ func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error)
return common.Address{}, err
}
+// ImportRawKey stores the given hex encoded ECDSA key into the key directory,
+// encrypting it with the passphrase.
func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) {
hexkey, err := hex.DecodeString(privkey)
if err != nil {
@@ -482,6 +492,34 @@ func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool {
return s.am.Lock(addr) == nil
}
+// SignAndSendTransaction will create a transaction from the given arguments and
+// tries to sign it with the key associated with args.To. If the given passwd isn't
+// able to decrypt the key it fails.
+func (s *PrivateAccountAPI) SignAndSendTransaction(args SendTxArgs, passwd string) (common.Hash, error) {
+ args = prepareSendTxArgs(args, s.gpo)
+
+ s.txMu.Lock()
+ defer s.txMu.Unlock()
+
+ if args.Nonce == nil {
+ args.Nonce = rpc.NewHexNumber(s.txPool.State().GetNonce(args.From))
+ }
+
+ var tx *types.Transaction
+ if args.To == nil {
+ tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ } else {
+ tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
+ }
+
+ signature, err := s.am.SignWithPassphrase(args.From, passwd, tx.SigHash().Bytes())
+ if err != nil {
+ return common.Hash{}, err
+ }
+
+ return submitTransaction(s.txPool, tx, signature)
+}
+
// PublicBlockChainAPI provides an API to access the Ethereum blockchain.
// It offers only methods that operate on public data that is freely available to anyone.
type PublicBlockChainAPI struct {
@@ -645,15 +683,14 @@ func (s *PublicBlockChainAPI) NewBlocks(ctx context.Context, args NewBlocksArgs)
// add a callback that is called on chain events which will format the block and notify the client
s.muNewBlockSubscriptions.Lock()
s.newBlockSubscriptions[subscription.ID()] = func(e core.ChainEvent) error {
- if notification, err := s.rpcOutputBlock(e.Block, args.IncludeTransactions, args.TransactionDetails); err == nil {
+ notification, err := s.rpcOutputBlock(e.Block, args.IncludeTransactions, args.TransactionDetails)
+ if err == nil {
return subscription.Notify(notification)
- } else {
- glog.V(logger.Warn).Info("unable to format block %v\n", err)
}
+ glog.V(logger.Warn).Info("unable to format block %v\n", err)
return nil
}
s.muNewBlockSubscriptions.Unlock()
-
return subscription, nil
}
@@ -700,6 +737,7 @@ func (m callmsg) Gas() *big.Int { return m.gas }
func (m callmsg) Value() *big.Int { return m.value }
func (m callmsg) Data() []byte { return m.data }
+// CallArgs represents the arguments for a call.
type CallArgs struct {
From common.Address `json:"from"`
To *common.Address `json:"to"`
@@ -911,7 +949,7 @@ type PublicTransactionPoolAPI struct {
miner *miner.Miner
am *accounts.Manager
txPool *core.TxPool
- txMu sync.Mutex
+ txMu *sync.Mutex
muPendingTxSubs sync.Mutex
pendingTxSubs map[string]rpc.Subscription
}
@@ -925,6 +963,7 @@ func NewPublicTransactionPoolAPI(e *Ethereum) *PublicTransactionPoolAPI {
bc: e.blockchain,
am: e.accountManager,
txPool: e.txPool,
+ txMu: &e.txMu,
miner: e.miner,
pendingTxSubs: make(map[string]rpc.Subscription),
}
@@ -1124,6 +1163,7 @@ func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transacti
return tx.WithSignature(signature)
}
+// SendTxArgs represents the arguments to sumbit a new transaction into the transaction pool.
type SendTxArgs struct {
From common.Address `json:"from"`
To *common.Address `json:"to"`
@@ -1134,18 +1174,47 @@ type SendTxArgs struct {
Nonce *rpc.HexNumber `json:"nonce"`
}
-// SendTransaction will create a transaction for the given transaction argument, sign it and submit it to the
-// transaction pool.
-func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash, error) {
+// prepareSendTxArgs is a helper function that fills in default values for unspecified tx fields.
+func prepareSendTxArgs(args SendTxArgs, gpo *GasPriceOracle) SendTxArgs {
if args.Gas == nil {
args.Gas = rpc.NewHexNumber(defaultGas)
}
if args.GasPrice == nil {
- args.GasPrice = rpc.NewHexNumber(s.gpo.SuggestPrice())
+ args.GasPrice = rpc.NewHexNumber(gpo.SuggestPrice())
}
if args.Value == nil {
args.Value = rpc.NewHexNumber(0)
}
+ return args
+}
+
+// submitTransaction is a helper function that submits tx to txPool and creates a log entry.
+func submitTransaction(txPool *core.TxPool, tx *types.Transaction, signature []byte) (common.Hash, error) {
+ signedTx, err := tx.WithSignature(signature)
+ if err != nil {
+ return common.Hash{}, err
+ }
+
+ txPool.SetLocal(signedTx)
+ if err := txPool.Add(signedTx); err != nil {
+ return common.Hash{}, err
+ }
+
+ if signedTx.To() == nil {
+ from, _ := signedTx.From()
+ addr := crypto.CreateAddress(from, signedTx.Nonce())
+ glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signedTx.Hash().Hex(), addr.Hex())
+ } else {
+ glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signedTx.Hash().Hex(), tx.To().Hex())
+ }
+
+ return signedTx.Hash(), nil
+}
+
+// SendTransaction creates a transaction for the given argument, sign it and submit it to the
+// transaction pool.
+func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash, error) {
+ args = prepareSendTxArgs(args, s.gpo)
s.txMu.Lock()
defer s.txMu.Unlock()
@@ -1155,32 +1224,18 @@ func (s *PublicTransactionPoolAPI) SendTransaction(args SendTxArgs) (common.Hash
}
var tx *types.Transaction
- contractCreation := (args.To == nil)
-
- if contractCreation {
+ if args.To == nil {
tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
} else {
tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
}
- signedTx, err := s.sign(args.From, tx)
+ signature, err := s.am.Sign(args.From, tx.SigHash().Bytes())
if err != nil {
return common.Hash{}, err
}
- s.txPool.SetLocal(signedTx)
- if err := s.txPool.Add(signedTx); err != nil {
- return common.Hash{}, err
- }
-
- if contractCreation {
- addr := crypto.CreateAddress(args.From, args.Nonce.Uint64())
- glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signedTx.Hash().Hex(), addr.Hex())
- } else {
- glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signedTx.Hash().Hex(), tx.To().Hex())
- }
-
- return signedTx.Hash(), nil
+ return submitTransaction(s.txPool, tx, signature)
}
// SendRawTransaction will add the signed transaction to the transaction pool.
@@ -1217,6 +1272,7 @@ func (s *PublicTransactionPoolAPI) Sign(addr common.Address, hash common.Hash) (
return common.ToHex(signature), error
}
+// SignTransactionArgs represents the arguments to sign a transaction.
type SignTransactionArgs struct {
From common.Address
To *common.Address
@@ -1243,6 +1299,7 @@ type Tx struct {
Hash common.Hash `json:"hash"`
}
+// UnmarshalJSON parses JSON data into tx.
func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
req := struct {
To *common.Address `json:"to"`
@@ -1283,8 +1340,7 @@ func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
tx.GasPrice = rpc.NewHexNumber(int64(50000000000))
}
- contractCreation := (req.To == nil)
- if contractCreation {
+ if req.To == nil {
tx.tx = types.NewContractCreation(tx.Nonce.Uint64(), tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
} else {
tx.tx = types.NewTransaction(tx.Nonce.Uint64(), *tx.To, tx.Value.BigInt(), tx.GasLimit.BigInt(), tx.GasPrice.BigInt(), data)
@@ -1293,6 +1349,7 @@ func (tx *Tx) UnmarshalJSON(b []byte) (err error) {
return nil
}
+// SignTransactionResult represents a RLP encoded signed transaction.
type SignTransactionResult struct {
Raw string `json:"raw"`
Tx *Tx `json:"tx"`
@@ -1335,9 +1392,7 @@ func (s *PublicTransactionPoolAPI) SignTransaction(args SignTransactionArgs) (*S
}
var tx *types.Transaction
- contractCreation := (args.To == nil)
-
- if contractCreation {
+ if args.To == nil {
tx = types.NewContractCreation(args.Nonce.Uint64(), args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
} else {
tx = types.NewTransaction(args.Nonce.Uint64(), *args.To, args.Value.BigInt(), args.Gas.BigInt(), args.GasPrice.BigInt(), common.FromHex(args.Data))
@@ -1360,7 +1415,7 @@ func (s *PublicTransactionPoolAPI) SignTransaction(args SignTransactionArgs) (*S
// the accounts this node manages.
func (s *PublicTransactionPoolAPI) PendingTransactions() []*RPCTransaction {
pending := s.txPool.GetTransactions()
- transactions := make([]*RPCTransaction, 0)
+ transactions := make([]*RPCTransaction, 0, len(pending))
for _, tx := range pending {
from, _ := tx.FromFrontier()
if s.am.HasAddress(from) {
@@ -1370,7 +1425,7 @@ func (s *PublicTransactionPoolAPI) PendingTransactions() []*RPCTransaction {
return transactions
}
-// NewPendingTransaction creates a subscription that is triggered each time a transaction enters the transaction pool
+// NewPendingTransactions creates a subscription that is triggered each time a transaction enters the transaction pool
// and is send from one of the transactions this nodes manages.
func (s *PublicTransactionPoolAPI) NewPendingTransactions(ctx context.Context) (rpc.Subscription, error) {
notifier, supported := rpc.NotifierFromContext(ctx)
@@ -1410,8 +1465,7 @@ func (s *PublicTransactionPoolAPI) Resend(tx Tx, gasPrice, gasLimit *rpc.HexNumb
}
var newTx *types.Transaction
- contractCreation := (tx.tx.To() == nil)
- if contractCreation {
+ if tx.tx.To() == nil {
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())
@@ -1612,7 +1666,7 @@ func (api *PrivateDebugAPI) ChaindbProperty(property string) (string, error) {
return ldb.LDB().GetProperty(property)
}
-// BlockTraceResults is the returned value when replaying a block to check for
+// BlockTraceResult is the returned value when replaying a block to check for
// consensus results and full VM trace logs for all included transactions.
type BlockTraceResult struct {
Validated bool `json:"validated"`
@@ -1647,7 +1701,7 @@ func (api *PrivateDebugAPI) TraceBlockFromFile(file string, config *vm.Config) B
return api.TraceBlock(blockRlp, config)
}
-// TraceProcessBlock processes the block by canonical block number.
+// TraceBlockByNumber processes the block by canonical block number.
func (api *PrivateDebugAPI) TraceBlockByNumber(number uint64, config *vm.Config) BlockTraceResult {
// Fetch the block that we aim to reprocess
block := api.eth.BlockChain().GetBlockByNumber(number)
@@ -1752,15 +1806,6 @@ type structLogRes struct {
Storage map[string]string `json:"storage"`
}
-// VmLoggerOptions are the options used for debugging transactions and capturing
-// specific data.
-type VmLoggerOptions struct {
- DisableMemory bool // disable memory capture
- DisableStack bool // disable stack capture
- DisableStorage bool // disable storage capture
- FullStorage bool // show full storage (slow)
-}
-
// formatLogs formats EVM returned structured logs for json output
func formatLogs(structLogs []vm.StructLog) []structLogRes {
formattedStructLogs := make([]structLogRes, len(structLogs))
@@ -1802,25 +1847,25 @@ func formatError(err error) string {
// TraceTransaction returns the structured logs created during the execution of EVM
// and returns them as a JSON object.
-func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogConfig) (*ExecutionResult, error) {
+func (api *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogConfig) (*ExecutionResult, error) {
if logger == nil {
logger = new(vm.LogConfig)
}
// Retrieve the tx from the chain and the containing block
- tx, blockHash, _, txIndex := core.GetTransaction(s.eth.ChainDb(), txHash)
+ tx, blockHash, _, txIndex := core.GetTransaction(api.eth.ChainDb(), txHash)
if tx == nil {
return nil, fmt.Errorf("transaction %x not found", txHash)
}
- block := s.eth.BlockChain().GetBlock(blockHash)
+ block := api.eth.BlockChain().GetBlock(blockHash)
if block == nil {
return nil, fmt.Errorf("block %x not found", blockHash)
}
// Create the state database to mutate and eventually trace
- parent := s.eth.BlockChain().GetBlock(block.ParentHash())
+ parent := api.eth.BlockChain().GetBlock(block.ParentHash())
if parent == nil {
return nil, fmt.Errorf("block parent %x not found", block.ParentHash())
}
- stateDb, err := state.New(parent.Root(), s.eth.ChainDb())
+ stateDb, err := state.New(parent.Root(), api.eth.ChainDb())
if err != nil {
return nil, err
}
@@ -1841,7 +1886,7 @@ func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogCon
}
// Mutate the state if we haven't reached the tracing transaction yet
if uint64(idx) < txIndex {
- vmenv := core.NewEnv(stateDb, s.config, s.eth.BlockChain(), msg, block.Header(), vm.Config{})
+ vmenv := core.NewEnv(stateDb, api.config, api.eth.BlockChain(), msg, block.Header(), vm.Config{})
_, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()))
if err != nil {
return nil, fmt.Errorf("mutation failed: %v", err)
@@ -1849,7 +1894,7 @@ func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogCon
continue
}
// Otherwise trace the transaction and return
- vmenv := core.NewEnv(stateDb, s.config, s.eth.BlockChain(), msg, block.Header(), vm.Config{Debug: true, Logger: *logger})
+ vmenv := core.NewEnv(stateDb, api.config, api.eth.BlockChain(), msg, block.Header(), vm.Config{Debug: true, Logger: *logger})
ret, gas, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas()))
if err != nil {
return nil, fmt.Errorf("tracing failed: %v", err)
@@ -1863,6 +1908,7 @@ func (s *PrivateDebugAPI) TraceTransaction(txHash common.Hash, logger *vm.LogCon
return nil, errors.New("database inconsistency")
}
+// TraceCall executes a call and returns the amount of gas, created logs and optionally returned values.
func (s *PublicBlockChainAPI) TraceCall(args CallArgs, blockNr rpc.BlockNumber) (*ExecutionResult, error) {
// Fetch the state associated with the block number
stateDb, block, err := stateAndBlockByNumber(s.miner, s.bc, blockNr, s.chainDb)
@@ -1931,12 +1977,12 @@ func (s *PublicNetAPI) Listening() bool {
return true // always listening
}
-// Peercount returns the number of connected peers
+// PeerCount returns the number of connected peers
func (s *PublicNetAPI) PeerCount() *rpc.HexNumber {
return rpc.NewHexNumber(s.net.PeerCount())
}
-// ProtocolVersion returns the current ethereum protocol version.
+// Version returns the current ethereum protocol version.
func (s *PublicNetAPI) Version() string {
return fmt.Sprintf("%d", s.networkVersion)
}
diff --git a/eth/backend.go b/eth/backend.go
index f43dea777..bb487650b 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -26,6 +26,7 @@ import (
"path/filepath"
"regexp"
"strings"
+ "sync"
"time"
"github.com/ethereum/ethash"
@@ -113,6 +114,7 @@ type Ethereum struct {
// Handlers
txPool *core.TxPool
+ txMu sync.Mutex
blockchain *core.BlockChain
accountManager *accounts.Manager
pow *ethash.Ethash
@@ -293,7 +295,7 @@ func (s *Ethereum) APIs() []rpc.API {
}, {
Namespace: "personal",
Version: "1.0",
- Service: NewPrivateAccountAPI(s.accountManager),
+ Service: NewPrivateAccountAPI(s),
Public: false,
}, {
Namespace: "eth",
diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go
index 9ce106cb8..8d5d1500f 100644
--- a/internal/web3ext/web3ext.go
+++ b/internal/web3ext/web3ext.go
@@ -431,6 +431,12 @@ web3._extend({
name: 'importRawKey',
call: 'personal_importRawKey',
params: 2
+ }),
+ new web3._extend.Method({
+ name: 'signAndSendTransaction',
+ call: 'personal_signAndSendTransaction',
+ params: 2,
+ inputFormatter: [web3._extend.formatters.inputTransactionFormatter, null]
})
]
});
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-06 09:11:53 +0800