func makeBlock() *types.Block { parentHash := common.HexToHash("0x01") coinbase := common.HexToAddress("0x01") root := common.HexToHash("0x01") difficulty := common.Big1 nonce := uint64(1) block := types.NewBlock(parentHash, coinbase, root, difficulty, nonce, nil) txto := common.HexToAddress("0x02") txamount := big.NewInt(1) txgasAmount := big.NewInt(1) txgasPrice := big.NewInt(1) txdata := []byte{1, 2, 3} tx := types.NewTransactionMessage(txto, txamount, txgasAmount, txgasPrice, txdata) txs := make([]*types.Transaction, 1) txs[0] = tx block.SetTransactions(txs) uncles := make([]*types.Header, 1) uncles[0] = makeHeader() block.SetUncles(uncles) return block }
func TestNewTransactionRes(t *testing.T) { to := common.HexToAddress("0x02") amount := big.NewInt(1) gasAmount := big.NewInt(1) gasPrice := big.NewInt(1) data := []byte{1, 2, 3} tx := types.NewTransactionMessage(to, amount, gasAmount, gasPrice, data) tests := map[string]string{ "hash": reHash, "nonce": reNum, "blockHash": reHashOpt, "blockNum": reNumOpt, "transactionIndex": reNumOpt, "from": reAddress, "to": reAddressOpt, "value": reNum, "gas": reNum, "gasPrice": reNum, "input": reData, } v := NewTransactionRes(tx) v.BlockHash = newHexData(common.HexToHash("0x030201")) v.BlockNumber = newHexNum(5) v.TxIndex = newHexNum(0) j, _ := json.Marshal(v) for k, re := range tests { match, _ := regexp.MatchString(fmt.Sprintf(`{.*"%s":%s.*}`, k, re), string(j)) if !match { t.Error(fmt.Sprintf("`%s` output json does not match format %s. Source %s", k, re, j)) } } }
func newtx(from *crypto.Key, nonce uint64, datasize int) *types.Transaction { data := make([]byte, datasize) tx := types.NewTransactionMessage(common.Address{}, big.NewInt(0), big.NewInt(100000), big.NewInt(0), data) tx.SetNonce(nonce) return tx }
func transaction() *types.Transaction { return types.NewTransactionMessage(common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(100), nil) }
func (self *XEth) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { // this minimalistic recoding is enough (works for natspec.js) var jsontx = fmt.Sprintf(`{"params":[{"to":"%s","data": "%s"}]}`, toStr, codeStr) if !self.ConfirmTransaction(jsontx) { err := fmt.Errorf("Transaction not confirmed") return "", err } var ( from = common.HexToAddress(fromStr) to = common.HexToAddress(toStr) value = common.NewValue(valueStr) gas = common.Big(gasStr) price = common.Big(gasPriceStr) data []byte contractCreation bool ) // TODO if no_private_key then //if _, exists := p.register[args.From]; exists { // p.register[args.From] = append(p.register[args.From], args) //} else { /* account := accounts.Get(common.FromHex(args.From)) if account != nil { if account.Unlocked() { if !unlockAccount(account) { return } } result, _ := account.Transact(common.FromHex(args.To), common.FromHex(args.Value), common.FromHex(args.Gas), common.FromHex(args.GasPrice), common.FromHex(args.Data)) if len(result) > 0 { *reply = common.ToHex(result) } } else if _, exists := p.register[args.From]; exists { p.register[ags.From] = append(p.register[args.From], args) } */ // TODO: align default values to have the same type, e.g. not depend on // common.Value conversions later on if gas.Cmp(big.NewInt(0)) == 0 { gas = DefaultGas() } if price.Cmp(big.NewInt(0)) == 0 { price = DefaultGasPrice() } data = common.FromHex(codeStr) if len(toStr) == 0 { contractCreation = true } var tx *types.Transaction if contractCreation { tx = types.NewContractCreationTx(value.BigInt(), gas, price, data) } else { tx = types.NewTransactionMessage(to, value.BigInt(), gas, price, data) } state := self.backend.ChainManager().TxState() var nonce uint64 if len(nonceStr) != 0 { nonce = common.Big(nonceStr).Uint64() } else { nonce = state.NewNonce(from) } tx.SetNonce(nonce) if err := self.sign(tx, from, false); err != nil { return "", err } if err := self.backend.TxPool().Add(tx); err != nil { return "", err } if contractCreation { addr := core.AddressFromMessage(tx) glog.V(logger.Info).Infof("Tx(%x) created: %x\n", tx.Hash(), addr) return core.AddressFromMessage(tx).Hex(), nil } else { glog.V(logger.Info).Infof("Tx(%x) to: %x\n", tx.Hash(), tx.To()) } return tx.Hash().Hex(), nil }