diff --git a/cli/smartcontract/smart_contract.go b/cli/smartcontract/smart_contract.go index 333aa01c1..4cd604e59 100644 --- a/cli/smartcontract/smart_contract.go +++ b/cli/smartcontract/smart_contract.go @@ -194,6 +194,7 @@ func testInvoke(ctx *cli.Context) error { return nil } +// ContractDetails contains contract metadata. type ContractDetails struct { Author string Email string diff --git a/config/config.go b/config/config.go index e5e856f35..6873de7d5 100644 --- a/config/config.go +++ b/config/config.go @@ -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) { diff --git a/examples/engine/engine.go b/examples/engine/engine.go index aa210abdf..b2d3fdfe5 100644 --- a/examples/engine/engine.go +++ b/examples/engine/engine.go @@ -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) diff --git a/examples/iterator/iterator.go b/examples/iterator/iterator.go index 0809b173f..593ab168e 100644 --- a/examples/iterator/iterator.go +++ b/examples/iterator/iterator.go @@ -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) diff --git a/examples/runtime/runtime.go b/examples/runtime/runtime.go index 4d914e445..8b935854a 100644 --- a/examples/runtime/runtime.go +++ b/examples/runtime/runtime.go @@ -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() diff --git a/examples/storage/storage.go b/examples/storage/storage.go index 319e9e71f..c12f5a5c9 100644 --- a/examples/storage/storage.go +++ b/examples/storage/storage.go @@ -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() diff --git a/examples/token/token.go b/examples/token/token.go index 1f1c62fa8..b8111c55d 100644 --- a/examples/token/token.go +++ b/examples/token/token.go @@ -1,4 +1,4 @@ -package token_contract +package tokencontract import ( "github.com/CityOfZion/neo-go/examples/token/nep5" diff --git a/pkg/core/blockchain.go b/pkg/core/blockchain.go index a6c0bd7b1..864b10284 100644 --- a/pkg/core/blockchain.go +++ b/pkg/core/blockchain.go @@ -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,43 +791,41 @@ 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, - Amount: output.Amount, - }) + } + for _, output := range references { + tempResults = append(tempResults, &transaction.Result{ + AssetID: output.AssetID, + Amount: output.Amount, + }) + } + for _, output := range t.Outputs { + tempResults = append(tempResults, &transaction.Result{ + AssetID: output.AssetID, + Amount: -output.Amount, + }) + } + for _, r := range tempResults { + if amount, ok := tempGroupResult[r.AssetID]; ok { + tempGroupResult[r.AssetID] = amount.Add(r.Amount) + } else { + tempGroupResult[r.AssetID] = r.Amount } - for _, output := range t.Outputs { - tempResults = append(tempResults, &transaction.Result{ - AssetID: output.AssetID, - Amount: -output.Amount, - }) - } - for _, r := range tempResults { - if amount, ok := tempGroupResult[r.AssetID]; ok { - tempGroupResult[r.AssetID] = amount.Add(r.Amount) - } else { - tempGroupResult[r.AssetID] = r.Amount - } - } - - results = []*transaction.Result{} // this assignment is necessary. (Most of the time amount == 0 and results is the empty slice.) - for assetID, amount := range tempGroupResult { - if amount != util.Fixed8(0) { - results = append(results, &transaction.Result{ - AssetID: assetID, - Amount: amount, - }) - } - } - - return results - } + results = []*transaction.Result{} // this assignment is necessary. (Most of the time amount == 0 and results is the empty slice.) + for assetID, amount := range tempGroupResult { + if amount != util.Fixed8(0) { + results = append(results, &transaction.Result{ + AssetID: assetID, + Amount: amount, + }) + } + } + + return results } // GetScriptHashesForVerifying returns all the ScriptHashes of a transaction which will be use diff --git a/pkg/core/blockchain_test.go b/pkg/core/blockchain_test.go index aec494683..bb98bcc24 100644 --- a/pkg/core/blockchain_test.go +++ b/pkg/core/blockchain_test.go @@ -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) } diff --git a/pkg/core/transaction/attribute.go b/pkg/core/transaction/attribute.go index b54273d40..3619fe931 100644 --- a/pkg/core/transaction/attribute.go +++ b/pkg/core/transaction/attribute.go @@ -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, diff --git a/pkg/core/transaction/claim.go b/pkg/core/transaction/claim.go index 0b5418506..468ce0f19 100644 --- a/pkg/core/transaction/claim.go +++ b/pkg/core/transaction/claim.go @@ -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 { diff --git a/pkg/core/transaction/contract.go b/pkg/core/transaction/contract.go index 3bcde6d37..e36a1ded4 100644 --- a/pkg/core/transaction/contract.go +++ b/pkg/core/transaction/contract.go @@ -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 } diff --git a/pkg/core/transaction/enrollment.go b/pkg/core/transaction/enrollment.go index 884525afe..752f6b9ee 100644 --- a/pkg/core/transaction/enrollment.go +++ b/pkg/core/transaction/enrollment.go @@ -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()) } diff --git a/pkg/core/transaction/invocation.go b/pkg/core/transaction/invocation.go index 54de3fb00..d23a8f59d 100644 --- a/pkg/core/transaction/invocation.go +++ b/pkg/core/transaction/invocation.go @@ -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) { diff --git a/pkg/core/transaction/issue.go b/pkg/core/transaction/issue.go index 3a2af4e9d..1a82d2df6 100644 --- a/pkg/core/transaction/issue.go +++ b/pkg/core/transaction/issue.go @@ -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 } diff --git a/pkg/core/transaction/miner.go b/pkg/core/transaction/miner.go index 32c41fa48..3f99ad125 100644 --- a/pkg/core/transaction/miner.go +++ b/pkg/core/transaction/miner.go @@ -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 } diff --git a/pkg/core/transaction/publish.go b/pkg/core/transaction/publish.go index 9dd896e89..3a3c735f3 100644 --- a/pkg/core/transaction/publish.go +++ b/pkg/core/transaction/publish.go @@ -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) diff --git a/pkg/core/transaction/register.go b/pkg/core/transaction/register.go index 1403e7433..96e5e1c6c 100644 --- a/pkg/core/transaction/register.go +++ b/pkg/core/transaction/register.go @@ -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() } diff --git a/pkg/core/transaction/state.go b/pkg/core/transaction/state.go index 66636aebb..5ee0c4a0d 100644 --- a/pkg/core/transaction/state.go +++ b/pkg/core/transaction/state.go @@ -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 { diff --git a/pkg/core/transaction/state_descriptor.go b/pkg/core/transaction/state_descriptor.go index a9447c9db..80a30ab04 100644 --- a/pkg/core/transaction/state_descriptor.go +++ b/pkg/core/transaction/state_descriptor.go @@ -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) } diff --git a/pkg/core/transaction/transaction.go b/pkg/core/transaction/transaction.go index 32583196f..90efcc777 100644 --- a/pkg/core/transaction/transaction.go +++ b/pkg/core/transaction/transaction.go @@ -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 { diff --git a/pkg/core/transaction/type.go b/pkg/core/transaction/type.go index ae0d8982c..e7cc222f8 100644 --- a/pkg/core/transaction/type.go +++ b/pkg/core/transaction/type.go @@ -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 diff --git a/pkg/crypto/base58.go b/pkg/crypto/base58.go index 43fc91884..6890aae17 100644 --- a/pkg/crypto/base58.go +++ b/pkg/crypto/base58.go @@ -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)...) diff --git a/pkg/crypto/keys/nep2.go b/pkg/crypto/keys/nep2.go index 1dcde69ef..fc40fb899 100644 --- a/pkg/crypto/keys/nep2.go +++ b/pkg/crypto/keys/nep2.go @@ -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, diff --git a/pkg/crypto/keys/private_key.go b/pkg/crypto/keys/private_key.go index 4f975d2b0..9e35590ed 100644 --- a/pkg/crypto/keys/private_key.go +++ b/pkg/crypto/keys/private_key.go @@ -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) diff --git a/pkg/crypto/keys/publickey.go b/pkg/crypto/keys/publickey.go index ae2b14adf..d5ea7e419 100644 --- a/pkg/crypto/keys/publickey.go +++ b/pkg/crypto/keys/publickey.go @@ -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) diff --git a/pkg/crypto/keys/wif.go b/pkg/crypto/keys/wif.go index 874774a91..4fcd71860 100644 --- a/pkg/crypto/keys/wif.go +++ b/pkg/crypto/keys/wif.go @@ -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 diff --git a/pkg/crypto/merkle_tree.go b/pkg/crypto/merkle_tree.go index a1cf339e8..e47fe4ae0 100644 --- a/pkg/crypto/merkle_tree.go +++ b/pkg/crypto/merkle_tree.go @@ -8,7 +8,6 @@ import ( ) // MerkleTree implementation. - type MerkleTree struct { root *MerkleTreeNode depth int diff --git a/pkg/internal/keytestcases/testcases.go b/pkg/internal/keytestcases/testcases.go index b2fd83366..5213b26d2 100644 --- a/pkg/internal/keytestcases/testcases.go +++ b/pkg/internal/keytestcases/testcases.go @@ -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", diff --git a/pkg/interop/account/account.go b/pkg/interop/account/account.go index c25903c1b..c2e4cb19c 100644 --- a/pkg/interop/account/account.go +++ b/pkg/interop/account/account.go @@ -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 } diff --git a/pkg/interop/asset/asset.go b/pkg/interop/asset/asset.go index a7a46db97..3c84ea367 100644 --- a/pkg/interop/asset/asset.go +++ b/pkg/interop/asset/asset.go @@ -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) {} diff --git a/pkg/interop/iterator/iterator.go b/pkg/interop/iterator/iterator.go index c63d3b93d..2dd17d2eb 100644 --- a/pkg/interop/iterator/iterator.go +++ b/pkg/interop/iterator/iterator.go @@ -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 } diff --git a/pkg/interop/transaction/transaction.go b/pkg/interop/transaction/transaction.go index 550c796d4..1acd54814 100644 --- a/pkg/interop/transaction/transaction.go +++ b/pkg/interop/transaction/transaction.go @@ -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 } diff --git a/pkg/network/payload/merkleblock.go b/pkg/network/payload/merkleblock.go index f39b9789a..3b1e90eae 100644 --- a/pkg/network/payload/merkleblock.go +++ b/pkg/network/payload/merkleblock.go @@ -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 } diff --git a/pkg/network/payload/version_test.go b/pkg/network/payload/version_test.go index c67e8357b..ca4ed156d 100644 --- a/pkg/network/payload/version_test.go +++ b/pkg/network/payload/version_test.go @@ -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) diff --git a/pkg/network/peer.go b/pkg/network/peer.go index e3b6f3854..6d698a11e 100644 --- a/pkg/network/peer.go +++ b/pkg/network/peer.go @@ -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) diff --git a/pkg/network/tcp_peer.go b/pkg/network/tcp_peer.go index 6d3cca187..1a63fea7e 100644 --- a/pkg/network/tcp_peer.go +++ b/pkg/network/tcp_peer.go @@ -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, diff --git a/pkg/rpc/client.go b/pkg/rpc/client.go index e21b4ef6a..ef76da4db 100644 --- a/pkg/rpc/client.go +++ b/pkg/rpc/client.go @@ -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() diff --git a/pkg/rpc/neoScanBalanceGetter.go b/pkg/rpc/neoScanBalanceGetter.go index d763d5f24..5e7b6150d 100644 --- a/pkg/rpc/neoScanBalanceGetter.go +++ b/pkg/rpc/neoScanBalanceGetter.go @@ -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 { diff --git a/pkg/rpc/neoScanTypes.go b/pkg/rpc/neoScanTypes.go index b0134277a..0ac7f2441 100644 --- a/pkg/rpc/neoScanTypes.go +++ b/pkg/rpc/neoScanTypes.go @@ -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", diff --git a/pkg/rpc/rpc.go b/pkg/rpc/rpc.go index cdf60be7e..73d62c421 100644 --- a/pkg/rpc/rpc.go +++ b/pkg/rpc/rpc.go @@ -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 diff --git a/pkg/rpc/server_test.go b/pkg/rpc/server_test.go index 03b18acd7..e719df3ae 100644 --- a/pkg/rpc/server_test.go +++ b/pkg/rpc/server_test.go @@ -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)) diff --git a/pkg/rpc/stack_param.go b/pkg/rpc/stack_param.go index ff62b5424..00072f2ce 100644 --- a/pkg/rpc/stack_param.go +++ b/pkg/rpc/stack_param.go @@ -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 diff --git a/pkg/rpc/txBuilder.go b/pkg/rpc/txBuilder.go index eaf55f294..401af25fd 100644 --- a/pkg/rpc/txBuilder.go +++ b/pkg/rpc/txBuilder.go @@ -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 diff --git a/pkg/rpc/txTypes.go b/pkg/rpc/txTypes.go index 584d968cf..96ad082d5 100644 --- a/pkg/rpc/txTypes.go +++ b/pkg/rpc/txTypes.go @@ -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) } ) diff --git a/pkg/rpc/types.go b/pkg/rpc/types.go index 3a51fd9ed..28e6a8d3d 100644 --- a/pkg/rpc/types.go +++ b/pkg/rpc/types.go @@ -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"` diff --git a/pkg/rpc/wrappers/asset_state.go b/pkg/rpc/wrappers/asset_state.go index f4e32e33b..c439af8d9 100644 --- a/pkg/rpc/wrappers/asset_state.go +++ b/pkg/rpc/wrappers/asset_state.go @@ -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"` diff --git a/pkg/rpc/wrappers/validate_address.go b/pkg/rpc/wrappers/validate_address.go index 83390976d..cea0ab64a 100644 --- a/pkg/rpc/wrappers/validate_address.go +++ b/pkg/rpc/wrappers/validate_address.go @@ -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"` diff --git a/pkg/smartcontract/param_context.go b/pkg/smartcontract/param_context.go index 166012bfa..b23d95b2d 100644 --- a/pkg/smartcontract/param_context.go +++ b/pkg/smartcontract/param_context.go @@ -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 } diff --git a/pkg/util/uint160.go b/pkg/util/uint160.go index 6da50850e..996bd9334 100644 --- a/pkg/util/uint160.go +++ b/pkg/util/uint160.go @@ -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 } diff --git a/pkg/util/uint256.go b/pkg/util/uint256.go index fbf9a41a1..0dbad3f89 100644 --- a/pkg/util/uint256.go +++ b/pkg/util/uint256.go @@ -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 } diff --git a/pkg/vm/stack_item.go b/pkg/vm/stack_item.go index a0d59b3ae..cec438d6b 100644 --- a/pkg/vm/stack_item.go +++ b/pkg/vm/stack_item.go @@ -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 } diff --git a/pkg/vm/state.go b/pkg/vm/state.go index 62d4367b2..5f2a549d2 100644 --- a/pkg/vm/state.go +++ b/pkg/vm/state.go @@ -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] != '"' { diff --git a/pkg/vm/tests/bar/bar.go b/pkg/vm/tests/bar/bar.go index c75928251..6f086a556 100644 --- a/pkg/vm/tests/bar/bar.go +++ b/pkg/vm/tests/bar/bar.go @@ -1,5 +1,6 @@ package bar +// Bar is something used for testing purposes (TODO: move somewhere?) type Bar struct { X int Y int diff --git a/pkg/vm/vm.go b/pkg/vm/vm.go index eff7dac51..a7d9e4c3b 100644 --- a/pkg/vm/vm.go +++ b/pkg/vm/vm.go @@ -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() diff --git a/pkg/wallet/wallet.go b/pkg/wallet/wallet.go index 691eca18c..413a318fb 100644 --- a/pkg/wallet/wallet.go +++ b/pkg/wallet/wallet.go @@ -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()