aboutsummaryrefslogblamecommitdiffstats
path: root/eth/wallet.go
blob: 9ec83430945d63ad2a1bc10fb174010ade8400ec (plain) (tree)















































































                                                                                                 
package eth

/*
import (
    "crypto/ecdsa"
    "errors"
    "math/big"

    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
)

type Account struct {
    w *Wallet
}

func (self *Account) Transact(to *Account, value, gas, price *big.Int, data []byte) error {
    return self.w.transact(self, to, value, gas, price, data)
}

func (self *Account) Address() []byte {
    return nil
}

func (self *Account) PrivateKey() *ecdsa.PrivateKey {
    return nil
}

type Wallet struct{}

func NewWallet() *Wallet {
    return &Wallet{}
}

func (self *Wallet) GetAccount(i int) *Account {
}

func (self *Wallet) transact(from, to *Account, value, gas, price *big.Int, data []byte) error {
    if from.PrivateKey() == nil {
        return errors.New("accounts is not owned (no private key available)")
    }

    var createsContract bool
    if to == nil {
        createsContract = true
    }

    var msg *types.Transaction
    if contractCreation {
        msg = types.NewContractCreationTx(value, gas, price, data)
    } else {
        msg = types.NewTransactionMessage(to.Address(), value, gas, price, data)
    }

    state := self.chainManager.TransState()
    nonce := state.GetNonce(key.Address())

    msg.SetNonce(nonce)
    msg.SignECDSA(from.PriateKey())

    // Do some pre processing for our "pre" events  and hooks
    block := self.chainManager.NewBlock(from.Address())
    coinbase := state.GetOrNewStateObject(from.Address())
    coinbase.SetGasPool(block.GasLimit())
    self.blockManager.ApplyTransactions(coinbase, state, block, types.Transactions{tx}, true)

    err := self.obj.TxPool().Add(tx)
    if err != nil {
        return nil, err
    }
    state.SetNonce(key.Address(), nonce+1)

    if contractCreation {
        addr := core.AddressFromMessage(tx)
        pipelogger.Infof("Contract addr %x\n", addr)
    }

    return tx, nil
}
*/