diff --git a/ethchain/transaction.go b/ethchain/transaction.go
index 421f26c98c9289d07d13b8a21c8d0bb962ebc98d..e93e610be54e66045f9c8191b6dd9bcdaba5bffb 100644
--- a/ethchain/transaction.go
+++ b/ethchain/transaction.go
@@ -59,6 +59,10 @@ func (tx *Transaction) IsContract() bool {
return tx.contractCreation
}
+func (tx *Transaction) CreationAddress() []byte {
+ return tx.Hash()[12:]
+}
+
func (tx *Transaction) Signature(key []byte) []byte {
hash := tx.Hash()
diff --git a/ethpub/pub.go b/ethpub/pub.go
new file mode 100644
index 0000000000000000000000000000000000000000..c6f177124afed44ac85deee7fec74e44c49c6f60
--- /dev/null
+++ b/ethpub/pub.go
@@ -0,0 +1,108 @@
+package ethpub
+
+import (
+ "github.com/ethereum/eth-go"
+ "github.com/ethereum/eth-go/ethchain"
+ "github.com/ethereum/eth-go/ethutil"
+)
+
+type PEthereum struct {
+ stateManager *ethchain.StateManager
+ blockChain *ethchain.BlockChain
+ txPool *ethchain.TxPool
+}
+
+func NewPEthereum(eth *eth.Ethereum) *PEthereum {
+ return &PEthereum{
+ eth.StateManager(),
+ eth.BlockChain(),
+ eth.TxPool(),
+ }
+}
+
+func (lib *PEthereum) GetBlock(hexHash string) *PBlock {
+ hash := ethutil.FromHex(hexHash)
+
+ block := lib.blockChain.GetBlock(hash)
+
+ return &PBlock{Number: int(block.BlockInfo().Number), Hash: ethutil.Hex(block.Hash())}
+}
+
+func (lib *PEthereum) GetKey() *PKey {
+ keyPair, err := ethchain.NewKeyPairFromSec(ethutil.Config.Db.GetKeys()[0].PrivateKey)
+ if err != nil {
+ return nil
+ }
+
+ return NewPKey(keyPair)
+}
+
+func (lib *PEthereum) GetStateObject(address string) *PStateObject {
+ stateObject := lib.stateManager.ProcState().GetContract(ethutil.FromHex(address))
+ if stateObject != nil {
+ return NewPStateObject(stateObject)
+ }
+
+ // See GetStorage for explanation on "nil"
+ return NewPStateObject(nil)
+}
+
+func (lib *PEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) (*PReceipt, error) {
+ return lib.createTx(key, recipient, valueStr, gasStr, gasPriceStr, dataStr, "")
+}
+
+func (lib *PEthereum) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr string) (*PReceipt, error) {
+ return lib.createTx(key, "", valueStr, gasStr, gasPriceStr, initStr, bodyStr)
+}
+
+func (lib *PEthereum) createTx(key, recipient, valueStr, gasStr, gasPriceStr, initStr, scriptStr string) (*PReceipt, error) {
+ var hash []byte
+ var contractCreation bool
+ if len(recipient) == 0 {
+ contractCreation = true
+ } else {
+ hash = ethutil.FromHex(recipient)
+ }
+
+ keyPair, err := ethchain.NewKeyPairFromSec([]byte(ethutil.FromHex(key)))
+ if err != nil {
+ return nil, err
+ }
+
+ value := ethutil.Big(valueStr)
+ gas := ethutil.Big(gasStr)
+ gasPrice := ethutil.Big(gasPriceStr)
+ var tx *ethchain.Transaction
+ // Compile and assemble the given data
+ if contractCreation {
+ initScript, err := ethutil.Compile(initStr)
+ if err != nil {
+ return nil, err
+ }
+ mainScript, err := ethutil.Compile(scriptStr)
+ if err != nil {
+ return nil, err
+ }
+
+ tx = ethchain.NewContractCreationTx(value, gas, gasPrice, mainScript, initScript)
+ } else {
+ // Just in case it was submitted as a 0x prefixed string
+ if initStr[0:2] == "0x" {
+ initStr = initStr[2:len(initStr)]
+ }
+ tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, ethutil.FromHex(initStr))
+ }
+
+ acc := lib.stateManager.GetAddrState(keyPair.Address())
+ tx.Nonce = acc.Nonce
+ tx.Sign(keyPair.PrivateKey)
+ lib.txPool.QueueTransaction(tx)
+
+ if contractCreation {
+ ethutil.Config.Log.Infof("Contract addr %x", tx.CreationAddress())
+ } else {
+ ethutil.Config.Log.Infof("Tx hash %x", tx.Hash())
+ }
+
+ return NewPReciept(contractCreation, tx.CreationAddress(), tx.Hash(), keyPair.Address()), nil
+}
diff --git a/ethpub/types.go b/ethpub/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..bf06ce2f64bcbfea60192ffc74caf527f5b19ce2
--- /dev/null
+++ b/ethpub/types.go
@@ -0,0 +1,107 @@
+package ethpub
+
+import (
+ "encoding/hex"
+ "github.com/ethereum/eth-go/ethchain"
+ "github.com/ethereum/eth-go/ethutil"
+)
+
+// Block interface exposed to QML
+type PBlock struct {
+ Number int
+ Hash string
+}
+
+// Creates a new QML Block from a chain block
+func NewPBlock(block *ethchain.Block) *PBlock {
+ info := block.BlockInfo()
+ hash := hex.EncodeToString(block.Hash())
+
+ return &PBlock{Number: int(info.Number), Hash: hash}
+}
+
+type PTx struct {
+ Value, Hash, Address string
+ Contract bool
+}
+
+func NewPTx(tx *ethchain.Transaction) *PTx {
+ hash := hex.EncodeToString(tx.Hash())
+ sender := hex.EncodeToString(tx.Recipient)
+ isContract := len(tx.Data) > 0
+
+ return &PTx{Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: sender, Contract: isContract}
+}
+
+type PKey struct {
+ Address string
+ PrivateKey string
+ PublicKey string
+}
+
+func NewPKey(key *ethchain.KeyPair) *PKey {
+ return &PKey{ethutil.Hex(key.Address()), ethutil.Hex(key.PrivateKey), ethutil.Hex(key.PublicKey)}
+}
+
+type PReceipt struct {
+ CreatedContract bool
+ Address string
+ Hash string
+ Sender string
+}
+
+func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt {
+ return &PReceipt{
+ contractCreation,
+ ethutil.Hex(creationAddress),
+ ethutil.Hex(hash),
+ ethutil.Hex(address),
+ }
+}
+
+/*
+type PKeyRing struct {
+ Keys []interface{}
+}
+
+func NewPKeyRing(keys []interface{}) *PKeyRing {
+ return &PKeyRing{Keys: keys}
+}
+*/
+
+type PStateObject struct {
+ object *ethchain.StateObject
+}
+
+func NewPStateObject(object *ethchain.StateObject) *PStateObject {
+ return &PStateObject{object: object}
+}
+
+func (c *PStateObject) GetStorage(address string) string {
+ // Because somehow, even if you return nil to QML it
+ // still has some magical object so we can't rely on
+ // undefined or null at the QML side
+ if c.object != nil {
+ val := c.object.GetMem(ethutil.Big("0x" + address))
+
+ return val.BigInt().String()
+ }
+
+ return ""
+}
+
+func (c *PStateObject) Value() string {
+ if c.object != nil {
+ return c.object.Amount.String()
+ }
+
+ return ""
+}
+
+func (c *PStateObject) Address() string {
+ if c.object != nil {
+ return ethutil.Hex(c.object.Address())
+ }
+
+ return ""
+}
diff --git a/ethutil/script.go b/ethutil/script.go
new file mode 100644
index 0000000000000000000000000000000000000000..620658025ad7dc982d9f598a1dee1f6c566e5ded
--- /dev/null
+++ b/ethutil/script.go
@@ -0,0 +1,41 @@
+package ethutil
+
+import (
+ "fmt"
+ "github.com/obscuren/mutan"
+ "strings"
+)
+
+// General compile function
+func Compile(script string) ([]byte, error) {
+ byteCode, errors := mutan.Compile(strings.NewReader(script), false)
+ if len(errors) > 0 {
+ var errs string
+ for _, er := range errors {
+ if er != nil {
+ errs += er.Error()
+ }
+ }
+ return nil, fmt.Errorf("%v", errs)
+ }
+
+ return byteCode, nil
+}
+
+func CompileScript(script string) ([]byte, []byte, error) {
+ // Preprocess
+ mainInput, initInput := mutan.PreProcess(script)
+ // Compile main script
+ mainScript, err := Compile(mainInput)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ // Compile init script
+ initScript, err := Compile(initInput)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ return mainScript, initScript, nil
+}