plugeth/chain/transaction.go

272 lines
6.1 KiB
Go
Raw Normal View History

2014-10-31 09:59:17 +00:00
package chain
2014-02-14 22:56:09 +00:00
import (
"bytes"
"fmt"
"math/big"
2014-10-31 11:37:43 +00:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethstate"
"github.com/ethereum/go-ethereum/ethutil"
2014-02-14 22:56:09 +00:00
"github.com/obscuren/secp256k1-go"
)
2014-02-19 10:35:17 +00:00
var ContractAddr = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
2014-06-19 11:42:47 +00:00
func IsContractAddr(addr []byte) bool {
return len(addr) == 0
//return bytes.Compare(addr, ContractAddr) == 0
2014-06-19 11:42:47 +00:00
}
2014-02-14 22:56:09 +00:00
type Transaction struct {
Nonce uint64
Recipient []byte
Value *big.Int
Gas *big.Int
2014-04-18 11:41:07 +00:00
GasPrice *big.Int
Data []byte
2014-02-14 22:56:09 +00:00
v byte
r, s []byte
2014-03-27 14:42:39 +00:00
// Indicates whether this tx is a contract creation transaction
contractCreation bool
2014-02-14 22:56:09 +00:00
}
2014-05-22 16:24:04 +00:00
func NewContractCreationTx(value, gas, gasPrice *big.Int, script []byte) *Transaction {
return &Transaction{Recipient: nil, Value: value, Gas: gas, GasPrice: gasPrice, Data: script, contractCreation: true}
}
func NewTransactionMessage(to []byte, value, gas, gasPrice *big.Int, data []byte) *Transaction {
return &Transaction{Recipient: to, Value: value, GasPrice: gasPrice, Gas: gas, Data: data, contractCreation: IsContractAddr(to)}
}
2014-02-25 10:22:18 +00:00
func NewTransactionFromBytes(data []byte) *Transaction {
2014-02-14 22:56:09 +00:00
tx := &Transaction{}
tx.RlpDecode(data)
return tx
}
func NewTransactionFromValue(val *ethutil.Value) *Transaction {
tx := &Transaction{}
tx.RlpValueDecode(val)
return tx
}
2014-06-13 10:45:11 +00:00
func (self *Transaction) GasValue() *big.Int {
return new(big.Int).Mul(self.Gas, self.GasPrice)
}
func (self *Transaction) TotalValue() *big.Int {
v := self.GasValue()
return v.Add(v, self.Value)
}
2014-02-14 22:56:09 +00:00
func (tx *Transaction) Hash() []byte {
data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data}
2014-10-31 11:37:43 +00:00
return crypto.Sha3(ethutil.NewValue(data).Encode())
2014-02-14 22:56:09 +00:00
}
func (tx *Transaction) CreatesContract() bool {
return tx.contractCreation
2014-02-14 22:56:09 +00:00
}
/* Deprecated */
func (tx *Transaction) IsContract() bool {
return tx.CreatesContract()
}
2014-10-02 15:03:15 +00:00
func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
// Generate a new address
2014-10-31 11:37:43 +00:00
addr := crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
2014-10-02 15:03:15 +00:00
//for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
2014-10-31 11:37:43 +00:00
// addr = crypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce + i}).Encode())[12:]
2014-10-02 15:03:15 +00:00
//}
return addr
2014-05-02 12:08:54 +00:00
}
2014-02-14 22:56:09 +00:00
func (tx *Transaction) Signature(key []byte) []byte {
hash := tx.Hash()
sig, _ := secp256k1.Sign(hash, key)
return sig
}
func (tx *Transaction) PublicKey() []byte {
hash := tx.Hash()
2014-07-01 22:05:48 +00:00
// TODO
r := ethutil.LeftPadBytes(tx.r, 32)
s := ethutil.LeftPadBytes(tx.s, 32)
2014-02-14 22:56:09 +00:00
sig := append(r, s...)
2014-02-14 22:56:09 +00:00
sig = append(sig, tx.v-27)
2014-10-31 11:37:43 +00:00
pubkey := crypto.Ecrecover(append(hash, sig...))
//pubkey, _ := secp256k1.RecoverPubkey(hash, sig)
2014-02-14 22:56:09 +00:00
return pubkey
}
func (tx *Transaction) Sender() []byte {
pubkey := tx.PublicKey()
// Validate the returned key.
// Return nil if public key isn't in full format
if pubkey[0] != 4 {
return nil
}
2014-10-31 11:37:43 +00:00
return crypto.Sha3(pubkey[1:])[12:]
2014-02-14 22:56:09 +00:00
}
func (tx *Transaction) Sign(privk []byte) error {
sig := tx.Signature(privk)
tx.r = sig[:32]
tx.s = sig[32:64]
tx.v = sig[64] + 27
return nil
}
func (tx *Transaction) RlpData() interface{} {
2014-05-20 11:06:47 +00:00
data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data}
// TODO Remove prefixing zero's
return append(data, tx.v, new(big.Int).SetBytes(tx.r).Bytes(), new(big.Int).SetBytes(tx.s).Bytes())
2014-02-14 22:56:09 +00:00
}
func (tx *Transaction) RlpValue() *ethutil.Value {
return ethutil.NewValue(tx.RlpData())
}
func (tx *Transaction) RlpEncode() []byte {
return tx.RlpValue().Encode()
}
func (tx *Transaction) RlpDecode(data []byte) {
tx.RlpValueDecode(ethutil.NewValueFromBytes(data))
}
func (tx *Transaction) RlpValueDecode(decoder *ethutil.Value) {
tx.Nonce = decoder.Get(0).Uint()
2014-05-20 11:06:47 +00:00
tx.GasPrice = decoder.Get(1).BigInt()
tx.Gas = decoder.Get(2).BigInt()
tx.Recipient = decoder.Get(3).Bytes()
tx.Value = decoder.Get(4).BigInt()
tx.Data = decoder.Get(5).Bytes()
tx.v = byte(decoder.Get(6).Uint())
2014-06-20 18:12:08 +00:00
tx.r = decoder.Get(7).Bytes()
tx.s = decoder.Get(8).Bytes()
2014-06-19 11:42:47 +00:00
if IsContractAddr(tx.Recipient) {
tx.contractCreation = true
}
}
func (tx *Transaction) String() string {
return fmt.Sprintf(`
TX(%x)
Contract: %v
From: %x
2014-05-22 15:56:33 +00:00
To: %x
Nonce: %v
GasPrice: %v
Gas: %v
Value: %v
Data: 0x%x
V: 0x%x
R: 0x%x
S: 0x%x
`,
tx.Hash(),
len(tx.Recipient) == 0,
tx.Sender(),
2014-05-22 15:56:33 +00:00
tx.Recipient,
tx.Nonce,
tx.GasPrice,
tx.Gas,
tx.Value,
tx.Data,
tx.v,
tx.r,
tx.s)
}
type Receipt struct {
PostState []byte
CumulativeGasUsed *big.Int
Bloom []byte
logs ethstate.Logs
}
func NewRecieptFromValue(val *ethutil.Value) *Receipt {
r := &Receipt{}
r.RlpValueDecode(val)
return r
}
func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) {
self.PostState = decoder.Get(0).Bytes()
self.CumulativeGasUsed = decoder.Get(1).BigInt()
self.Bloom = decoder.Get(2).Bytes()
it := decoder.Get(3).NewIterator()
for it.Next() {
self.logs = append(self.logs, ethstate.NewLogFromValue(it.Value()))
}
}
func (self *Receipt) RlpData() interface{} {
return []interface{}{self.PostState, self.CumulativeGasUsed, self.Bloom, self.logs.RlpData()}
}
func (self *Receipt) RlpEncode() []byte {
return ethutil.Encode(self.RlpData())
2014-02-14 22:56:09 +00:00
}
2014-07-14 20:52:44 +00:00
func (self *Receipt) Cmp(other *Receipt) bool {
if bytes.Compare(self.PostState, other.PostState) != 0 {
return false
}
return true
}
type Receipts []*Receipt
func (self Receipts) Len() int { return len(self) }
func (self Receipts) GetRlp(i int) []byte { return ethutil.Rlp(self[i]) }
// Transaction slice type for basic sorting
type Transactions []*Transaction
func (self Transactions) RlpData() interface{} {
// Marshal the transactions of this block
enc := make([]interface{}, len(self))
for i, tx := range self {
// Cast it to a string (safe)
enc[i] = tx.RlpData()
}
return enc
}
func (s Transactions) Len() int { return len(s) }
func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s Transactions) GetRlp(i int) []byte { return ethutil.Rlp(s[i]) }
type TxByNonce struct{ Transactions }
func (s TxByNonce) Less(i, j int) bool {
return s.Transactions[i].Nonce < s.Transactions[j].Nonce
}