TrueCloudLab/neo-go
8
0
Fork 0
mirror of https://github.com/nspcc-dev/neo-go.git synced 2024-11-22 19:29:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #340 from nspcc-dev/fix-golint-213

Browse source 
Make our build green again! Fixes #213.
This commit is contained in:
Roman Khimov 2019-09-03 19:54:29 +03:00 committed by GitHub
commit e636537844
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
56 changed files with 180 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
cli/smartcontract/smart_contract.go
View file

@ -194,6 +194,7 @@ func testInvoke(ctx *cli.Context) error {
return nil
}
// ContractDetails contains contract metadata.
type ContractDetails struct {
Author string
Email string

9
config/config.go
View file

@ -15,10 +15,13 @@ import (
const (
userAgentFormat = "/NEO-GO:%s/"
// Valid NetMode constants.
// ModeMainNet contains magic code used in the NEO main official network.
ModeMainNet NetMode = 0x00746e41 // 7630401
// ModeTestNet contains magic code used in the NEO testing network.
ModeTestNet NetMode = 0x74746e41 // 1953787457
// ModePrivNet contains magic code usually used for NEO private networks.
ModePrivNet NetMode = 56753 // docker privnet
// ModeUnitTestNet is a stub magic code used for testing purposes.
ModeUnitTestNet NetMode = 0
)
@ -91,8 +94,8 @@ func (c Config) GenerateUserAgent() string {
return fmt.Sprintf(userAgentFormat, Version)
}
// Loadattempts to load the config from the give
// path and netMode.
// Load attempts to load the config from the given
// path for the given netMode.
func Load(path string, netMode NetMode) (Config, error) {
configPath := fmt.Sprintf("%s/protocol.%s.yml", path, netMode)
if _, err := os.Stat(configPath); os.IsNotExist(err) {

3
examples/engine/engine.go
View file

@ -1,10 +1,11 @@
package engine_contract
package enginecontract
import (
"github.com/CityOfZion/neo-go/pkg/interop/engine"
"github.com/CityOfZion/neo-go/pkg/interop/runtime"
)
// Main is that famous Main() function, you know.
func Main() bool {
tx := engine.GetScriptContainer()
runtime.Notify(tx)

3
examples/iterator/iterator.go
View file

@ -1,4 +1,4 @@
package iterator_contract
package iteratorcontract
import (
"github.com/CityOfZion/neo-go/pkg/interop/iterator"
@ -6,6 +6,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/interop/storage"
)
// Main is Main(), really.
func Main() bool {
iter := storage.Find(storage.GetContext(), []byte("foo"))
values := iterator.Values(iter)

3
examples/runtime/runtime.go
View file

@ -1,4 +1,4 @@
package runtime_contract
package runtimecontract
import (
"github.com/CityOfZion/neo-go/pkg/interop/runtime"
@ -8,6 +8,7 @@ import (
// Check if the invoker of the contract is the specified owner
var owner = util.FromAddress("Aej1fe4mUgou48Zzup5j8sPrE3973cJ5oz")
// Main is something to be ran from outside.
func Main(operation string, args []interface{}) bool {
trigger := runtime.GetTrigger()

3
examples/storage/storage.go
View file

@ -1,9 +1,10 @@
package storage_contract
package storagecontract
import (
"github.com/CityOfZion/neo-go/pkg/interop/storage"
)
// Main is a very useful function.
func Main(operation string, args []interface{}) interface{} {
ctx := storage.GetContext()

2
examples/token/token.go
View file

@ -1,4 +1,4 @@
package token_contract
package tokencontract
import (
"github.com/CityOfZion/neo-go/examples/token/nep5"

11
pkg/core/blockchain.go
View file

@ -83,7 +83,7 @@ func NewBlockchain(ctx context.Context, s storage.Store, cfg config.ProtocolConf
return bc, nil
}
// GetBlockchainLevelDB returns blockchain based on configuration
// NewBlockchainLevelDB initializes new blockchain DB store based on configuration
func NewBlockchainLevelDB(ctx context.Context, cfg config.Config) (*Blockchain, error) {
store, err := storage.NewLevelDBStore(
ctx,
@ -502,6 +502,7 @@ func (bc *Blockchain) GetBlock(hash util.Uint256) (*Block, error) {
return block, nil
}
// GetHeader returns data block header identified with the given hash value.
func (bc *Blockchain) GetHeader(hash util.Uint256) (*Header, error) {
b, err := bc.Get(storage.AppendPrefix(storage.DataBlock, hash.BytesReverse()))
if err != nil {
@ -790,9 +791,10 @@ func (bc *Blockchain) GetTransationResults(t *transaction.Transaction) []*transa
var results []*transaction.Result
tempGroupResult := make(map[util.Uint256]util.Fixed8)
if references := bc.References(t); references == nil {
references := bc.References(t)
if references == nil {
return nil
} else {
}
for _, output := range references {
tempResults = append(tempResults, &transaction.Result{
AssetID: output.AssetID,
@ -824,9 +826,6 @@ func (bc *Blockchain) GetTransationResults(t *transaction.Transaction) []*transa
}
return results
}
}
// GetScriptHashesForVerifying returns all the ScriptHashes of a transaction which will be use

1
pkg/core/blockchain_test.go
View file

@ -86,7 +86,6 @@ func TestGetHeader(t *testing.T) {
assert.Equal(t, block.Header(), header)
block = newBlock(2)
hash = block.Hash()
_, err = bc.GetHeader(block.Hash())
assert.Error(t, err)
}

2
pkg/core/transaction/attribute.go
View file

@ -64,7 +64,7 @@ func (attr *Attribute) EncodeBinary(w io.Writer) error {
Remark12, Remark13, Remark14, Remark15:
bw.WriteBytes(attr.Data)
case DescriptionURL:
var urllen uint8 = uint8(len(attr.Data))
var urllen = uint8(len(attr.Data))
bw.WriteLE(urllen)
fallthrough
case Script, ContractHash, Vote, Hash1, Hash2, Hash3, Hash4, Hash5, Hash6,

1
pkg/core/transaction/claim.go
View file

@ -43,6 +43,7 @@ func (tx *ClaimTX) EncodeBinary(w io.Writer) error {
return nil
}
// Size returns serialized binary size for this transaction.
func (tx *ClaimTX) Size() int {
sz := util.GetVarSize(uint64(len(tx.Claims)))
for _, claim := range tx.Claims {

2
pkg/core/transaction/contract.go
View file

@ -8,6 +8,7 @@ import (
// This TX has not special attributes.
type ContractTX struct{}
// NewContractTX creates Transaction of ContractType type.
func NewContractTX() *Transaction {
return &Transaction{
Type: ContractType,
@ -24,6 +25,7 @@ func (tx *ContractTX) EncodeBinary(w io.Writer) error {
return nil
}
// Size returns serialized binary size for this transaction.
func (tx *ContractTX) Size() int {
return 0
}

3
pkg/core/transaction/enrollment.go
View file

@ -6,7 +6,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/crypto/keys"
)
// A Enrollment transaction represents an enrollment form, which indicates
// EnrollmentTX transaction represents an enrollment form, which indicates
// that the sponsor of the transaction would like to sign up as a validator.
// The way to sign up is: To construct an EnrollmentTransaction type of transaction,
// and send a deposit to the address of the PublicKey.
@ -27,6 +27,7 @@ func (tx *EnrollmentTX) EncodeBinary(w io.Writer) error {
return tx.PublicKey.EncodeBinary(w)
}
// Size returns serialized binary size for this transaction.
func (tx *EnrollmentTX) Size() int {
return len(tx.PublicKey.Bytes())
}

1
pkg/core/transaction/invocation.go
View file

@ -54,6 +54,7 @@ func (tx *InvocationTX) EncodeBinary(w io.Writer) error {
return bw.Err
}
// Size returns serialized binary size for this transaction.
func (tx *InvocationTX) Size() int {
sz := util.GetVarSize(tx.Script)
if (tx.Version >= 1) {

1
pkg/core/transaction/issue.go
View file

@ -18,6 +18,7 @@ func (tx *IssueTX) EncodeBinary(w io.Writer) error {
return nil
}
// Size returns serialized binary size for this transaction.
func (tx *IssueTX) Size() int {
return 0
}

1
pkg/core/transaction/miner.go
View file

@ -21,6 +21,7 @@ func (tx *MinerTX) EncodeBinary(w io.Writer) error {
return binary.Write(w, binary.LittleEndian, tx.Nonce)
}
// Size returns serialized binary size for this transaction.
func (tx *MinerTX) Size() int {
return 4 // Nonce
}

5
pkg/core/transaction/publish.go
View file

@ -74,12 +74,13 @@ func (tx *PublishTX) EncodeBinary(w io.Writer) error {
return bw.Err
}
// Size returns serialized binary size for this transaction.
func (tx *PublishTX) Size() int {
sz := util.GetVarSize(tx.Script) + util.GetVarSize(uint64(len(tx.ParamList)))
sz += 1 * len(tx.ParamList)
sz += 1
sz++
if tx.Version >= 1 {
sz += 1
sz++
}
sz += util.GetVarSize(tx.Name) + util.GetVarSize(tx.CodeVersion)
sz += util.GetVarSize(tx.Author) + util.GetVarSize(tx.Email)

1
pkg/core/transaction/register.go
View file

@ -63,6 +63,7 @@ func (tx *RegisterTX) EncodeBinary(w io.Writer) error {
return bw.Err
}
// Size returns serialized binary size for this transaction.
func (tx *RegisterTX) Size() int {
return 1 + util.GetVarSize(tx.Name) + tx.Amount.Size() + 1 + len(tx.Owner.Bytes()) + tx.Admin.Size()
}

1
pkg/core/transaction/state.go
View file

@ -44,6 +44,7 @@ func (tx *StateTX) EncodeBinary(w io.Writer) error {
return nil
}
// Size returns serialized binary size for this transaction.
func (tx *StateTX) Size() int {
sz := util.GetVarSize(uint64(len(tx.Descriptors)))
for _, desc := range tx.Descriptors {

1
pkg/core/transaction/state_descriptor.go
View file

@ -45,6 +45,7 @@ func (s *StateDescriptor) EncodeBinary(w io.Writer) error {
return bw.Err
}
// Size returns serialized binary size for state descriptor.
func (s *StateDescriptor) Size() int {
return 1 + util.GetVarSize(s.Key) + util.GetVarSize(s.Value) + util.GetVarSize(s.Field)
}

2
pkg/core/transaction/transaction.go
View file

@ -251,7 +251,7 @@ func (t *Transaction) createHash() error {
return nil
}
// GroupTXInputsByPrevHash groups all TX inputs by their previous hash.
// GroupInputsByPrevHash groups all TX inputs by their previous hash.
func (t *Transaction) GroupInputsByPrevHash() map[util.Uint256][]*Input {
m := make(map[util.Uint256][]*Input)
for _, in := range t.Inputs {

1
pkg/core/transaction/type.go
View file

@ -3,6 +3,7 @@ package transaction
// TXType is the type of a transaction.
type TXType uint8
// Constants for all valid transaction types.
const (
MinerType TXType = 0x00
IssueType TXType = 0x01

6
pkg/crypto/base58.go
View file

@ -96,11 +96,11 @@ func Base58CheckDecode(s string) (b []byte, err error) {
}
if len(b) < 5 {
return nil, errors.New("invalid base-58 check string: missing checksum.")
return nil, errors.New("invalid base-58 check string: missing checksum")
}
if !bytes.Equal(hash.Checksum(b[:len(b)-4]), b[len(b)-4:]) {
return nil, errors.New("invalid base-58 check string: invalid checksum.")
return nil, errors.New("invalid base-58 check string: invalid checksum")
}
// Strip the 4 byte long hash.
@ -109,7 +109,7 @@ func Base58CheckDecode(s string) (b []byte, err error) {
return b, nil
}
// Base58checkEncode encodes b into a base-58 check encoded string.
// Base58CheckEncode encodes b into a base-58 check encoded string.
func Base58CheckEncode(b []byte) string {
b = append(b, hash.Checksum(b)...)

2
pkg/crypto/keys/nep2.go
View file

@ -24,12 +24,14 @@ const (
var nepHeader = []byte{0x01, 0x42}
// ScryptParams is a json-serializable container for scrypt KDF parameters.
type ScryptParams struct {
N int `json:"n"`
R int `json:"r"`
P int `json:"p"`
}
// NEP2ScryptParams returns scrypt parameters specified in the NEP-2.
func NEP2ScryptParams() ScryptParams {
return ScryptParams{
N: n,

1
pkg/crypto/keys/private_key.go
View file

@ -22,6 +22,7 @@ type PrivateKey struct {
b []byte
}
// NewPrivateKey creates a new random private key.
func NewPrivateKey() (*PrivateKey, error) {
c := crypto.NewEllipticCurve()
b := make([]byte, c.N.BitLen()/8+8)

4
pkg/crypto/keys/publickey.go
View file

@ -168,6 +168,7 @@ func (p *PublicKey) EncodeBinary(w io.Writer) error {
return binary.Write(w, binary.LittleEndian, p.Bytes())
}
// Signature returns a NEO-specific hash of the key.
func (p *PublicKey) Signature() []byte {
b := p.Bytes()
b = append([]byte{0x21}, b...)
@ -178,8 +179,9 @@ func (p *PublicKey) Signature() []byte {
return sig.Bytes()
}
// Address returns a base58-encoded NEO-specific address based on the key hash.
func (p *PublicKey) Address() string {
var b []byte = p.Signature()
var b = p.Signature()
b = append([]byte{0x17}, b...)
csum := hash.Checksum(b)

1
pkg/crypto/keys/wif.go
View file

@ -91,6 +91,7 @@ func WIFDecode(wif string, version byte) (*WIF, error) {
return w, nil
}
// GetVerificationScript returns NEO VM bytecode with checksig command for the public key.
func (wif WIF) GetVerificationScript() ([]byte, error) {
const (
pushbytes33 = 0x21

1
pkg/crypto/merkle_tree.go
View file

@ -8,7 +8,6 @@ import (
)
// MerkleTree implementation.
type MerkleTree struct {
root *MerkleTreeNode
depth int

2
pkg/internal/keytestcases/testcases.go
View file

@ -1,5 +1,6 @@
package keytestcases
// Ktype represents key testcase values (different encodings of the key).
type Ktype struct {
Address,
PrivateKey,
@ -9,6 +10,7 @@ type Ktype struct {
EncryptedWif string
}
// Arr contains a set of known keys in Ktype format.
var Arr = []Ktype{
{
Address: "ALq7AWrhAueN6mJNqk6FHJjnsEoPRytLdW",

2
pkg/interop/account/account.go
View file

@ -6,7 +6,7 @@ package account
// Account stubs a NEO account type.
type Account struct{}
// GetScripHash returns the script hash of the given account.
// GetScriptHash returns the script hash of the given account.
func GetScriptHash(a Account) []byte {
return nil
}

2
pkg/interop/asset/asset.go
View file

@ -49,5 +49,5 @@ func GetIssuer(a Asset) []byte {
// Create registers a new asset on the blockchain.
func Create(assetType byte, name string, amount int, precision byte, owner, admin, issuer []byte) {}
// Renew renews the existance of an asset by the given years.
// Renew renews the existence of an asset by the given years.
func Renew(asset Asset, years int) {}

2
pkg/interop/iterator/iterator.go
View file

@ -11,8 +11,8 @@ func Create(items []interface{}) Iterator {
return Iterator{}
}
// TODO: Better description for this.
// Key returns the iterator key.
// TODO: Better description for this.
func Key(it Iterator) interface{} {
return nil
}

4
pkg/interop/transaction/transaction.go
View file

@ -27,14 +27,14 @@ func GetAttributes(t Transaction) []attribute.Attribute {
return []attribute.Attribute{}
}
// FIXME: What is the correct return type for this?
// GetReferences returns a slice of references for the given transaction.
// FIXME: What is the correct return type for this?
func GetReferences(t Transaction) []interface{} {
return []interface{}{}
}
// FIXME: What is the correct return type for this?
// GetUnspentCoins returns the unspent coins for the given transaction.
// FIXME: What is the correct return type for this?
func GetUnspentCoins(t Transaction) interface{} {
return 0
}

3
pkg/network/payload/merkleblock.go
View file

@ -7,6 +7,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/util"
)
// MerkleBlock represents a merkle block packet payload.
type MerkleBlock struct {
*core.BlockBase
TxCount int
@ -14,6 +15,7 @@ type MerkleBlock struct {
Flags []byte
}
// DecodeBinary implements the Payload interface.
func (m *MerkleBlock) DecodeBinary(r io.Reader) error {
m.BlockBase = &core.BlockBase{}
if err := m.BlockBase.DecodeBinary(r); err != nil {
@ -31,6 +33,7 @@ func (m *MerkleBlock) DecodeBinary(r io.Reader) error {
return br.Err
}
// EncodeBinary implements the Payload interface.
func (m *MerkleBlock) EncodeBinary(w io.Writer) error {
return nil
}

2
pkg/network/payload/version_test.go
View file

@ -12,7 +12,7 @@ func TestVersionEncodeDecode(t *testing.T) {
var id uint32 = 13337
useragent := "/NEO:0.0.1/"
var height uint32 = 100500
var relay bool = true
var relay = true
version := NewVersion(id, port, useragent, height, relay)

1
pkg/network/peer.go
View file

@ -5,6 +5,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/util"
)
// Peer represents a network node neo-go is connected to.
type Peer interface {
Endpoint() util.Endpoint
Disconnect(error)

1
pkg/network/tcp_peer.go
View file

@ -23,6 +23,7 @@ type TCPPeer struct {
wg sync.WaitGroup
}
// NewTCPPeer returns a TCPPeer structure based on the given connection.
func NewTCPPeer(conn net.Conn) *TCPPeer {
return &TCPPeer{
conn: conn,

5
pkg/rpc/client.go
View file

@ -93,6 +93,7 @@ func NewClient(ctx context.Context, endpoint string, opts ClientOptions) (*Clien
}, nil
}
// WIF returns WIF structure associated with the client.
func (c *Client) WIF() keys.WIF {
c.wifMu.Lock()
defer c.wifMu.Unlock()
@ -117,12 +118,14 @@ func (c *Client) SetWIF(wif string) error {
return nil
}
// Balancer is a getter for balance field.
func (c *Client) Balancer() BalanceGetter {
c.balancerMu.Lock()
defer c.balancerMu.Unlock()
return c.balancer
}
// SetBalancer is a setter for balance field.
func (c *Client) SetBalancer(b BalanceGetter) {
c.balancerMu.Lock()
defer c.balancerMu.Unlock()
@ -132,12 +135,14 @@ func (c *Client) SetBalancer(b BalanceGetter) {
}
}
// Client is a getter for client field.
func (c *Client) Client() *http.Client {
c.cliMu.Lock()
defer c.cliMu.Unlock()
return c.cli
}
// SetClient is a setter for client field.
func (c *Client) SetClient(cli *http.Client) {
c.cliMu.Lock()
defer c.cliMu.Unlock()

8
pkg/rpc/neoScanBalanceGetter.go
View file

@ -11,6 +11,7 @@ import (
errs "github.com/pkg/errors"
)
// GetBalance performs a request to get balance for the address specified.
func (s NeoScanServer) GetBalance(address string) ([]*Unspent, error) {
var (
err error
@ -49,7 +50,8 @@ func filterSpecificAsset(asset string, balance []*Unspent, assetBalance *Unspent
}
}
func (s NeoScanServer) CalculateInputs(address string, assetIdUint util.Uint256, cost util.Fixed8) ([]transaction.Input, util.Fixed8, error) {
// CalculateInputs creates input transactions for the specified amount of given asset belonging to specified address.
func (s NeoScanServer) CalculateInputs(address string, assetIDUint util.Uint256, cost util.Fixed8) ([]transaction.Input, util.Fixed8, error) {
var (
err error
num, i uint16
@ -57,12 +59,12 @@ func (s NeoScanServer) CalculateInputs(address string, assetIdUint util.Uint256,
selected = util.Fixed8(0)
us []*Unspent
assetUnspent Unspent
assetId = GlobalAssets[assetIdUint.ReverseString()]
assetID = GlobalAssets[assetIDUint.ReverseString()]
)
if us, err = s.GetBalance(address); err != nil {
return nil, util.Fixed8(0), errs.Wrapf(err, "Cannot get balance for address %v", address)
}
filterSpecificAsset(assetId, us, &assetUnspent)
filterSpecificAsset(assetID, us, &assetUnspent)
sort.Sort(assetUnspent.Unspent)
for _, us := range assetUnspent.Unspent {

10
pkg/rpc/neoScanTypes.go
View file

@ -9,35 +9,37 @@ import "github.com/CityOfZion/neo-go/pkg/util"
*/
type (
// NeoScanServer stores NEOSCAN URL and API path
NeoScanServer struct {
URL string // "protocol://host:port/"
Path string // path to API endpoint without wallet address
}
// UTXO stores unspent TX output for some transaction.
UTXO struct {
Value util.Fixed8
TxID util.Uint256
N uint16
}
// Unspents is a slice of UTXOs (TODO: drop it?).
Unspents []UTXO
// unspent per asset
// Unspent stores Unspents per asset
Unspent struct {
Unspent Unspents
Asset string // "NEO" / "GAS"
Amount util.Fixed8 // total unspent of this asset
}
// struct of NeoScan response to 'get_balance' request
// NeoScanBalance is a struct of NeoScan response to 'get_balance' request
NeoScanBalance struct {
Balance []*Unspent
Address string
}
)
// NeoScan returns asset IDs as strings ("NEO"/"GAS");
// strings might be converted to uint256 assets IDs using this map
// GlobalAssets stores a map of asset IDs to user-friendly strings ("NEO"/"GAS");
var GlobalAssets = map[string]string{
"c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b": "NEO",
"602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7": "GAS",

62
pkg/rpc/rpc.go
View file

@ -10,21 +10,22 @@ import (
"github.com/pkg/errors"
)
// GetBlock returns a block by its hash or index/height. If verbose is true
// getBlock returns a block by its hash or index/height. If verbose is true
// the response will contain a pretty Block object instead of the raw hex string.
func (c *Client) GetBlock(indexOrHash interface{}, verbose bool) (*response, error) {
var (
params = newParams(indexOrHash)
resp = &response{}
)
if verbose {
params = newParams(indexOrHash, 1)
}
if err := c.performRequest("getblock", params, resp); err != nil {
return nil, err
}
return resp, nil
}
// missing output wrapper at the moment, thus commented out
// func (c *Client) getBlock(indexOrHash interface{}, verbose bool) (*response, error) {
// var (
// params = newParams(indexOrHash)
// resp = &response{}
// )
// if verbose {
// params = newParams(indexOrHash, 1)
// }
// if err := c.performRequest("getblock", params, resp); err != nil {
// return nil, err
// }
// return resp, nil
// }
// GetAccountState will return detailed information about a NEO account.
func (c *Client) GetAccountState(address string) (*AccountStateResponse, error) {
@ -65,7 +66,7 @@ func (c *Client) InvokeFunction(script, operation string, params []smartcontract
return resp, nil
}
// InvokeFunction return the results after calling a the smart contract scripthash
// Invoke returns the results after calling a the smart contract scripthash
// with the given parameters.
func (c *Client) Invoke(script string, params []smartcontract.Parameter) (*InvokeScriptResponse, error) {
var (
@ -78,23 +79,24 @@ func (c *Client) Invoke(script string, params []smartcontract.Parameter) (*Invok
return resp, nil
}
// GetRawTransaction queries a transaction by hash.
func (c *Client) GetRawTransaction(hash string, verbose bool) (*response, error) {
var (
params = newParams(hash, verbose)
resp = &response{}
)
if err := c.performRequest("getrawtransaction", params, resp); err != nil {
return nil, err
}
return resp, nil
}
// getRawTransaction queries a transaction by hash.
// missing output wrapper at the moment, thus commented out
// func (c *Client) getRawTransaction(hash string, verbose bool) (*response, error) {
// var (
// params = newParams(hash, verbose)
// resp = &response{}
// )
// if err := c.performRequest("getrawtransaction", params, resp); err != nil {
// return nil, err
// }
// return resp, nil
// }
// SendRawTransaction broadcasts a transaction over the NEO network.
// sendRawTransaction broadcasts a transaction over the NEO network.
// The given hex string needs to be signed with a keypair.
// When the result of the response object is true, the TX has successfully
// been broadcasted to the network.
func (c *Client) SendRawTransaction(rawTX string) (*response, error) {
func (c *Client) sendRawTransaction(rawTX string) (*response, error) {
var (
params = newParams(rawTX)
resp = &response{}
@ -115,7 +117,7 @@ func (c *Client) SendToAddress(asset util.Uint256, address string, amount util.F
rawTx *transaction.Transaction
rawTxStr string
txParams = ContractTxParams{
assetId: asset,
assetID: asset,
address: address,
value: amount,
wif: c.WIF(),
@ -132,7 +134,7 @@ func (c *Client) SendToAddress(asset util.Uint256, address string, amount util.F
return nil, errors.Wrap(err, "failed to encode raw transaction to binary for `sendtoaddress`")
}
rawTxStr = hex.EncodeToString(buf.Bytes())
if resp, err = c.SendRawTransaction(rawTxStr); err != nil {
if resp, err = c.sendRawTransaction(rawTxStr); err != nil {
return nil, errors.Wrap(err, "failed to send raw transaction")
}
response.Error = resp.Error

10
pkg/rpc/server_test.go
View file

@ -24,18 +24,18 @@ type tc struct {
expectedResult string
}
var testRpcCases = []tc{
var testRPCCases = []tc{
{
rpcCall: `{"jsonrpc": "2.0", "id": 1, "method": "getassetstate", "params": ["602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7"] }`,
method: "getassetstate_1",
expectedResult: `{"jsonrpc":"2.0","result":{"assetId":"0x602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7","assetType":1,"name":"NEOGas","amount":"100000000","available":"0","precision":8,"fee":0,"address":"0x0000000000000000000000000000000000000000","owner":"00","admin":"AWKECj9RD8rS8RPcpCgYVjk1DeYyHwxZm3","issuer":"AFmseVrdL9f9oyCzZefL9tG6UbvhPbdYzM","expiration":0,"is_frozen":false},"id":1}`,
expectedResult: `{"jsonrpc":"2.0","result":{"assetID":"0x602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7","assetType":1,"name":"NEOGas","amount":"100000000","available":"0","precision":8,"fee":0,"address":"0x0000000000000000000000000000000000000000","owner":"00","admin":"AWKECj9RD8rS8RPcpCgYVjk1DeYyHwxZm3","issuer":"AFmseVrdL9f9oyCzZefL9tG6UbvhPbdYzM","expiration":0,"is_frozen":false},"id":1}`,
},
{
rpcCall: `{ "jsonrpc": "2.0", "id": 1, "method": "getassetstate", "params": ["c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b"] }`,
method: "getassetstate_2",
expectedResult: `{"jsonrpc":"2.0","result":{"assetId":"0xc56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b","assetType":0,"name":"NEO","amount":"100000000","available":"0","precision":0,"fee":0,"address":"0x0000000000000000000000000000000000000000","owner":"00","admin":"Abf2qMs1pzQb8kYk9RuxtUb9jtRKJVuBJt","issuer":"AFmseVrdL9f9oyCzZefL9tG6UbvhPbdYzM","expiration":0,"is_frozen":false},"id":1}`,
expectedResult: `{"jsonrpc":"2.0","result":{"assetID":"0xc56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b","assetType":0,"name":"NEO","amount":"100000000","available":"0","precision":0,"fee":0,"address":"0x0000000000000000000000000000000000000000","owner":"00","admin":"Abf2qMs1pzQb8kYk9RuxtUb9jtRKJVuBJt","issuer":"AFmseVrdL9f9oyCzZefL9tG6UbvhPbdYzM","expiration":0,"is_frozen":false},"id":1}`,
},
{
@ -255,13 +255,13 @@ func TestHandler(t *testing.T) {
// setup handler
handler := http.HandlerFunc(rpcServer.requestHandler)
testRpcCases = append(testRpcCases, tc{
testRPCCases = append(testRPCCases, tc{
rpcCall: `{"jsonrpc": "2.0", "id": 1, "method": "getversion", "params": [] }`,
method: "getversion",
expectedResult: fmt.Sprintf(`{"jsonrpc":"2.0","result":{"port":20333,"nonce":%s,"useragent":"/NEO-GO:/"},"id":1}`, strconv.FormatUint(uint64(server.ID()), 10)),
})
for _, tc := range testRpcCases {
for _, tc := range testRPCCases {
t.Run(fmt.Sprintf("method: %s, rpc call: %s", tc.method, tc.rpcCall), func(t *testing.T) {
req := httptest.NewRequest("POST", "http://0.0.0.0:20333/", strings.NewReader(tc.rpcCall))

8
pkg/rpc/stack_param.go
View file

@ -10,8 +10,10 @@ import (
"github.com/pkg/errors"
)
// StackParamType represents different types of stack values.
type StackParamType int
// All possible StackParamType values are listed here
const (
Unknown StackParamType = -1
Signature StackParamType = 0x00
@ -27,6 +29,7 @@ const (
Void StackParamType = 0xff
)
// String implements the stringer interface.
func (t StackParamType) String() string {
switch t {
case Signature:
@ -56,6 +59,7 @@ func (t StackParamType) String() string {
}
}
// StackParamTypeFromString converts string into the StackParamType.
func StackParamTypeFromString(s string) (StackParamType, error) {
switch s {
case "Signature":
@ -85,6 +89,7 @@ func StackParamTypeFromString(s string) (StackParamType, error) {
}
}
// UnmarshalJSON sets StackParamType from JSON-encoded data.
func (t *StackParamType) UnmarshalJSON(data []byte) (err error) {
var (
s = string(data)
@ -174,8 +179,10 @@ func (p *StackParam) UnmarshalJSON(data []byte) (err error) {
return
}
// StackParams in an array of StackParam (TODO: drop it?).
type StackParams []StackParam
// TryParseArray converts an array of StackParam into an array of more appropriate things.
func (p StackParams) TryParseArray(vals ...interface{}) error {
var (
err error
@ -193,6 +200,7 @@ func (p StackParams) TryParseArray(vals ...interface{}) error {
return nil
}
// TryParse converts one StackParam into something more appropriate.
func (p StackParam) TryParse(dest interface{}) error {
var (
err error

4
pkg/rpc/txBuilder.go
View file

@ -10,6 +10,7 @@ import (
errs "github.com/pkg/errors"
)
// CreateRawContractTransaction returns contract-type Transaction built from specified parameters.
func CreateRawContractTransaction(params ContractTxParams) (*transaction.Transaction, error) {
var (
err error
@ -21,7 +22,7 @@ func CreateRawContractTransaction(params ContractTxParams) (*transaction.Transac
spent util.Fixed8
witness transaction.Witness
wif, assetID, address, amount, balancer = params.wif, params.assetId, params.address, params.value, params.balancer
wif, assetID, address, amount, balancer = params.wif, params.assetID, params.address, params.value, params.balancer
)
if fromAddress, err = wif.PrivateKey.Address(); err != nil {
@ -67,6 +68,7 @@ func CreateRawContractTransaction(params ContractTxParams) (*transaction.Transac
return tx, nil
}
// GetInvocationScript returns NEO VM script containing transaction signature.
func GetInvocationScript(tx *transaction.Transaction, wif keys.WIF) ([]byte, error) {
const (
pushbytes64 = 0x40

9
pkg/rpc/txTypes.go
View file

@ -12,11 +12,11 @@ import (
)
type (
// parameters for tx to transfer assets;
// ContractTxParams contains parameters for tx to transfer assets;
// includes parameters duplication `sendtoaddress` RPC call params
// and also some utility data;
ContractTxParams struct {
assetId util.Uint256
assetID util.Uint256
address string
value util.Fixed8
wif keys.WIF // a WIF to send the transaction
@ -26,15 +26,16 @@ type (
balancer BalanceGetter
}
// BalanceGetter is an interface supporting CalculateInputs() method.
BalanceGetter interface {
// parameters
// address: base58-encoded address assets would be transferred from
// assetId: asset identifier
// assetID: asset identifier
// amount: an asset amount to spend
// return values
// inputs: UTXO's for the preparing transaction
// total: summarized asset amount from all the `inputs`
// error: error would be considered in the caller function
CalculateInputs(address string, assetId util.Uint256, amount util.Fixed8) (inputs []transaction.Input, total util.Fixed8, err error)
CalculateInputs(address string, assetID util.Uint256, amount util.Fixed8) (inputs []transaction.Input, total util.Fixed8, err error)
}
)

10
pkg/rpc/types.go
View file

@ -5,6 +5,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/vm"
)
// InvokeScriptResponse stores response for the invoke script call.
type InvokeScriptResponse struct {
responseHeader
Error *Error `json:"error,omitempty"`
@ -73,19 +74,21 @@ type response struct {
Result interface{} `json:"result"`
}
// SendToAddressResponse stores response for the sendtoaddress call.
type SendToAddressResponse struct {
responseHeader
Error *Error `json:"error"`
Result *TxResponse
}
// struct represents verbose output of `getrawtransaction` RPC call
// GetRawTxResponse struct represents verbose output of `getrawtransaction` RPC call.
type GetRawTxResponse struct {
responseHeader
Error *Error `json:"error"`
Result *RawTxResponse `json:"result"`
}
// RawTxResponse stores transaction with blockchain metadata to be sent as a response.
type RawTxResponse struct {
TxResponse
BlockHash string `json:"blockhash"`
@ -93,6 +96,7 @@ type RawTxResponse struct {
BlockTime uint `json:"blocktime"`
}
// TxResponse stores transaction to be sent as a response.
type TxResponse struct {
TxID string `json:"txid"`
Size int `json:"size"`
@ -106,11 +110,13 @@ type TxResponse struct {
Scripts []transaction.Witness `json:"scripts"`
}
// Vin represents JSON-serializable tx input.
type Vin struct {
TxId string `json:"txid"`
TxID string `json:"txid"`
Vout int `json:"vout"`
}
// Vout represents JSON-serializable tx output.
type Vout struct {
N int `json:"n"`
Asset string `json:"asset"`

2
pkg/rpc/wrappers/asset_state.go
View file

@ -10,7 +10,7 @@ import (
// AssetState wrapper used for the representation of
// core.AssetState on the RPC Server.
type AssetState struct {
ID util.Uint256 `json:"assetId"`
ID util.Uint256 `json:"assetID"`
AssetType transaction.AssetType `json:"assetType"`
Name string `json:"name"`
Amount util.Fixed8 `json:"amount"`

1
pkg/rpc/wrappers/validate_address.go
View file

@ -4,6 +4,7 @@ import (
"github.com/CityOfZion/neo-go/pkg/crypto"
)
// ValidateAddressResponse represents response to validate address call.
type ValidateAddressResponse struct {
Address interface{} `json:"address"`
IsValid bool `json:"isvalid"`

1
pkg/smartcontract/param_context.go
View file

@ -51,6 +51,7 @@ func (pt ParamType) String() string {
}
}
// MarshalJSON implements the json.Marshaler interface.
func (pt ParamType) MarshalJSON() ([]byte, error) {
return []byte(`"` + pt.String() + `"`), nil
}

2
pkg/util/uint160.go
View file

@ -70,7 +70,7 @@ func (u *Uint160) UnmarshalJSON(data []byte) (err error) {
return err
}
// Size returns the lenght of the bytes representation of Uint160
// Size returns the length of the bytes representation of Uint160
func (u Uint160) Size() int {
return uint160Size
}

2
pkg/util/uint256.go
View file

@ -82,7 +82,7 @@ func (u *Uint256) UnmarshalJSON(data []byte) (err error) {
return err
}
// Size returns the lenght of the bytes representation of Uint256
// Size returns the length of the bytes representation of Uint256
func (u Uint256) Size() int {
return uint256Size
}

1
pkg/vm/stack_item.go
View file

@ -95,6 +95,7 @@ func (i *BigIntegerItem) MarshalJSON() ([]byte, error) {
return json.Marshal(i.value)
}
// BoolItem represents a boolean StackItem.
type BoolItem struct {
value bool
}

5
pkg/vm/state.go
View file

@ -17,10 +17,12 @@ const (
breakState
)
// HasFlag check for State flag presence.
func (s State) HasFlag(f State) bool {
return s&f != 0
}
// String implements the stringer interface.
func (s State) String() string {
if s == noneState {
return "NONE"
@ -39,6 +41,7 @@ func (s State) String() string {
return strings.Join(ss, ", ")
}
// StateFromString converts string into the VM State.
func StateFromString(s string) (st State, err error) {
if s = strings.TrimSpace(s); s == "NONE" {
return noneState, nil
@ -60,10 +63,12 @@ func StateFromString(s string) (st State, err error) {
return
}
// MarshalJSON implements the json.Marshaler interface
func (s State) MarshalJSON() (data []byte, err error) {
return []byte(`"` + s.String() + `"`), nil
}
// UnmarshalJSON implements the json.Marshaler interface
func (s *State) UnmarshalJSON(data []byte) (err error) {
l := len(data)
if l < 2 || data[0] != '"' || data[l-1] != '"' {

1
pkg/vm/tests/bar/bar.go
View file

@ -1,5 +1,6 @@
package bar
// Bar is something used for testing purposes (TODO: move somewhere?)
type Bar struct {
X int
Y int

1
pkg/vm/vm.go
View file

@ -133,6 +133,7 @@ func (v *VM) LoadFile(path string) error {
return nil
}
// Load initializes the VM with the program given.
func (v *VM) Load(prog []byte) {
// clear all stacks, it could be a reload.
v.istack.Clear()

2
pkg/wallet/wallet.go
View file

@ -74,7 +74,7 @@ func newWallet(rw io.ReadWriter) *Wallet {
}
}
// CreatAccount generates a new account for the end user and encrypts
// CreateAccount generates a new account for the end user and encrypts
// the private key with the given passphrase.
func (w *Wallet) CreateAccount(name, passphrase string) error {
acc, err := NewAccount()