Merge pull request #82 from proximax-storage/keypair_generate

Added keypair generator with pvkey #80 #77

README.md

@@ -17,11 +17,11 @@ Create a Catapult network configuration
 
 Using the *Testnet* network
 ```go
-conf, err := sdk.LoadTestnetConfig("http://localhost:3000")
+conf, err := sdk.NewConfig("http://localhost:3000",sdk.Testnet)
 ```
 Or using the *Mainnet* network
 ```go
-conf, err := sdk.LoadMainnetConfig("http://localhost:3000")
+conf, err := sdk.NewConfig("http://localhost:3000",sdk.Mainnet)
 ```
 
 Construct a new Catapult client

crypto/key_model.go

@@ -32,6 +32,7 @@ type PrivateKey struct {
 	Raw   []byte
 }
 
+
 // NewPrivateKey creates a new private key from []byte
 func NewPrivateKey(raw []byte) *PrivateKey {
 	return &PrivateKey{(&big.Int{}).SetBytes(raw), raw}
@@ -64,8 +65,7 @@ func NewPrivateKeyfromDecimalString(decimal string) (*PrivateKey, error) {
 }
 
 func (ref *PrivateKey) String() string {
-
-	return string(ref.Raw)
+	return hex.EncodeToString(ref.Raw)
 }
 
 //PublicKey  Represents a public key.

examples/blockchain_api/main.go

@@ -11,12 +11,15 @@ import (
 	"math/big"
 )
 
-const baseUrl = "http://localhost:3000"
+const (
+	baseUrl = "http://localhost:3000"
+	networkType = sdk.MijinTest
+)
 
 // Simple Blockchain API request
 func main() {
 
-	conf, err := sdk.LoadTestnetConfig(baseUrl)
+	conf, err := sdk.NewConfig(baseUrl,networkType)
 	if err != nil {
 		panic(err)
 	}

examples/websocket/main.go

@@ -21,12 +21,12 @@ const (
 // The notification is received in real time without having to poll the API waiting for a reply.
 func main() {
 
-	conf, err := sdk.LoadTestnetConfig(baseUrl)
+	conf, err := sdk.NewConfig(baseUrl,networkType)
 	if err != nil {
 		panic(err)
 	}
 
-	acc, err := sdk.NewAccount(privateKey, networkType)
+	acc, err := sdk.NewAccountFromPrivateKey(privateKey, networkType)
 
 	ws, err := sdk.NewConnectWs(baseUrl)
 	if err != nil {

sdk/account.go

@@ -13,6 +13,8 @@ import (
 
 type AccountService service
 
+
+
 func (a *AccountService) GetAccountInfo(ctx context.Context, address *Address) (*AccountInfo, *http.Response, error) {
 	dto := &accountInfoDTO{}
 

sdk/account_model.go

@@ -205,7 +205,7 @@ func (dto *multisigAccountInfoDTO) toStruct(networkType NetworkType) (*MultisigA
 	cs := make([]*PublicAccount, len(dto.Multisig.Cosignatories))
 	ms := make([]*PublicAccount, len(dto.Multisig.MultisigAccounts))
 
-	acc, err := NewPublicAccount(dto.Multisig.Account, networkType)
+	acc, err := NewAccountFromPublicKey(dto.Multisig.Account, networkType)
 	if err != nil {
 		return nil, err
 	}
@@ -214,14 +214,14 @@ func (dto *multisigAccountInfoDTO) toStruct(networkType NetworkType) (*MultisigA
 	go func() {
 		defer wg.Done()
 		for i, c := range dto.Multisig.Cosignatories {
-			cs[i], err = NewPublicAccount(c, networkType)
+			cs[i], err = NewAccountFromPublicKey(c, networkType)
 		}
 	}()
 
 	go func() {
 		defer wg.Done()
 		for i, m := range dto.Multisig.MultisigAccounts {
-			ms[i], err = NewPublicAccount(m, networkType)
+			ms[i], err = NewAccountFromPublicKey(m, networkType)
 		}
 	}()
 
@@ -285,7 +285,20 @@ func (dto multisigAccountGraphInfoDTOS) toStruct(networkType NetworkType) (*Mult
 
 var addressError = errors.New("wrong address")
 
-func NewAccount(pKey string, networkType NetworkType) (*Account, error) {
+func NewAccount(networkType NetworkType) (*Account, error) {
+	kp, err := crypto.NewKeyPairByEngine(crypto.CryptoEngines.DefaultEngine)
+	if err != nil {
+		return nil, err
+	}
+
+	pa, err := NewAccountFromPublicKey(kp.PublicKey.String(), networkType)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Account{pa, kp}, nil
+}
+func NewAccountFromPrivateKey(pKey string, networkType NetworkType) (*Account, error) {
 	k, err := crypto.NewPrivateKeyfromHexString(pKey)
 	if err != nil {
 		return nil, err
@@ -296,15 +309,15 @@ func NewAccount(pKey string, networkType NetworkType) (*Account, error) {
 		return nil, err
 	}
 
-	pa, err := NewPublicAccount(kp.PublicKey.String(), networkType)
+	pa, err := NewAccountFromPublicKey(kp.PublicKey.String(), networkType)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Account{pa, kp}, nil
 }
 
-func NewPublicAccount(pKey string, networkType NetworkType) (*PublicAccount, error) {
+func NewAccountFromPublicKey(pKey string, networkType NetworkType) (*PublicAccount, error) {
 	ad, err := NewAddressFromPublicKey(pKey, networkType)
 	if err != nil {
 		return nil, err

sdk/account_model_test.go

@@ -18,6 +18,18 @@ var testAddressesForEncoded = map[NetworkType]string{
 	MainNet:   "NARNASAS2BIAB6LMFA3FPMGBPGIJGK6IJFJKUV32",
 }
 
+func TestGenerateNewAccount_NEM(t *testing.T) {
+	acc, err := NewAccount(MijinTest)
+	if err != nil {
+		t.Fatal("Error")
+	}
+	a := acc.KeyPair.PrivateKey.String()
+	t.Log("Private Key: " + a)
+
+	assert.NotNil(t,acc.KeyPair.PrivateKey.String(),"Error generating new KeyPair")
+
+
+}
 func TestGenerateEncodedAddress_NEM(t *testing.T) {
 
 	for nType, testAddress := range testAddressesForEncoded {

sdk/blockchain_model.go

@@ -87,7 +87,7 @@ type blockInfoDTO struct {
 func (dto *blockInfoDTO) toStruct() (*BlockInfo, error) {
 	nt := ExtractNetworkType(dto.Block.Version)
 
-	pa, err := NewPublicAccount(dto.Block.Signer, nt)
+	pa, err := NewAccountFromPublicKey(dto.Block.Signer, nt)
 	if err != nil {
 		return nil, err
 	}

sdk/blockchain_test.go

@@ -110,7 +110,7 @@ var wantBlockInfo *BlockInfo
 func init() {
 	addRouters(bcRouters)
 
-	pubAcc, _ := NewPublicAccount("321DE652C4D3362FC2DDF7800F6582F4A10CFEA134B81F8AB6E4BE78BBA4D18E", MijinTest)
+	pubAcc, _ := NewAccountFromPublicKey("321DE652C4D3362FC2DDF7800F6582F4A10CFEA134B81F8AB6E4BE78BBA4D18E", MijinTest)
 
 	wantBlockInfo = &BlockInfo{
 		NetworkType:           MijinTest,

sdk/mosaic.go

@@ -154,7 +154,7 @@ func (dto mosaicPropertiesDTO) toStruct() *MosaicProperties {
 
 func (ref *mosaicInfoDTO) setMosaicInfo() (*MosaicInfo, error) {
 
-	publicAcc, err := NewPublicAccount(ref.Mosaic.Owner, NetworkType(1))
+	publicAcc, err := NewAccountFromPublicKey(ref.Mosaic.Owner, NetworkType(1))
 	if err != nil {
 		return nil, err
 	}

sdk/mosaic_test.go

@@ -93,7 +93,7 @@ var (
 
 func TestMosaicService_GetMosaic(t *testing.T) {
 
-	mscInfo, resp, err := serv.Mosaic.GetMosaic(ctx, *testMosaicId)
+	mscInfo, resp, err := serv.Mosaic.GetMosaic(ctx, testMosaicId)
 	if err != nil {
 		t.Error(err)
 	} else if validateResp(resp, t) && validateMosaicInfo(mscInfo, t) {
@@ -137,7 +137,6 @@ func TestMosaicService_GetMosaicNames(t *testing.T) {
 }
 
 func TestMosaicService_GetMosaicsFromNamespace(t *testing.T) {
-
 	mscInfoArr, resp, err := serv.Mosaic.GetMosaicsFromNamespace(ctx, testNamespaceId, testMosaicId, pageSize)
 	if err != nil {
 		t.Error(err)
@@ -150,6 +149,7 @@ func TestMosaicService_GetMosaicsFromNamespace(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	} else if validateResp(resp, t) {
+		t.Log(t)
 		t.Logf("%v", mscInfoArr)
 
 	}
@@ -159,11 +159,6 @@ func TestMosaicService_GetMosaicsFromNamespace(t *testing.T) {
 const iter = 1000
 
 func TestMosaicService_GetMosaicsFromNamespasceExt(t *testing.T) {
-
-	cfg, _ := LoadMainnetConfig("http://190.216.224.11:3000")
-
-	serv := NewClient(nil, cfg)
-
 	h, _, err := serv.Blockchain.GetBlockchainHeight(ctx)
 	if err != nil {
 		t.Fatal(err)
@@ -213,7 +208,7 @@ func TestMosaicService_GetMosaicsFromNamespasceExt(t *testing.T) {
 					t.Log(tran)
 					continue
 				}
-				mscInfo, resp, err := serv.Mosaic.GetMosaic(ctx, *tran.MosaicId)
+				mscInfo, resp, err := serv.Mosaic.GetMosaic(ctx, tran.MosaicId)
 				if err != nil {
 					t.Error(err)
 				} else if validateResp(resp, t) {

sdk/namespace.go

@@ -171,7 +171,7 @@ type namespaceInfoDTO struct {
 
 //getNamespaceInfo create & return new NamespaceInfo from namespaceInfoDTO
 func (ref *namespaceInfoDTO) getNamespaceInfo() (*NamespaceInfo, error) {
-	pubAcc, err := NewPublicAccount(ref.Namespace.Owner, NetworkType(ref.Namespace.Type))
+	pubAcc, err := NewAccountFromPublicKey(ref.Namespace.Owner, NetworkType(ref.Namespace.Type))
 	if err != nil {
 		return nil, err
 	}

sdk/namespace_test.go

@@ -115,11 +115,11 @@ func TestNamespaceService_GetNamespacesFromAccount(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	} else if validateResp(resp, t) {
-		if len(nsInfoArr.list) != 1 {
+		if len(nsInfoArr.List) != 1 {
 			t.Error("return result must have length = 1")
 		} else {
 			isValid := true
-			for _, nsInfo := range nsInfoArr.list {
+			for _, nsInfo := range nsInfoArr.List {
 				isValid = isValid && validateNamespaceInfo(nsInfo, t)
 			}
 			if isValid {
@@ -137,11 +137,11 @@ func TestNamespaceService_GetNamespacesFromAccounts(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	} else if validateResp(resp, t) {
-		if len(nsInfoArr.list) != 1 {
+		if len(nsInfoArr.List) != 1 {
 			t.Error("return result must have length = 1")
 		} else {
 			isValid := true
-			for _, nsInfo := range nsInfoArr.list {
+			for _, nsInfo := range nsInfoArr.List {
 				isValid = isValid && validateNamespaceInfo(nsInfo, t)
 			}
 			if isValid {

sdk/sdk_model.go

@@ -6,7 +6,7 @@ package sdk
 
 import (
 	"encoding/binary"
-	"github.com/Wondertan/nem2-sdk-go/utils"
+	"github.com/proximax-storage/nem2-sdk-go/utils"
 	"math/big"
 	"strconv"
 )

sdk/transaction_model.go

@@ -122,7 +122,7 @@ func (dto *abstractTransactionDTO) toStruct(tInfo *TransactionInfo) (*abstractTr
 		return nil, err
 	}
 
-	pa, err := NewPublicAccount(dto.Signer, nt)
+	pa, err := NewAccountFromPublicKey(dto.Signer, nt)
 	if err != nil {
 		return nil, err
 	}
@@ -1405,7 +1405,7 @@ type aggregateTransactionCosignatureDTO struct {
 }
 
 func (dto *aggregateTransactionCosignatureDTO) toStruct(networkType NetworkType) (*AggregateTransactionCosignature, error) {
-	acc, err := NewPublicAccount(dto.Signer, networkType)
+	acc, err := NewAccountFromPublicKey(dto.Signer, networkType)
 	if err != nil {
 		return nil, err
 	}
@@ -1449,7 +1449,7 @@ type multisigCosignatoryModificationDTO struct {
 }
 
 func (dto *multisigCosignatoryModificationDTO) toStruct(networkType NetworkType) (*MultisigCosignatoryModification, error) {
-	acc, err := NewPublicAccount(dto.PublicAccount, networkType)
+	acc, err := NewAccountFromPublicKey(dto.PublicAccount, networkType)
 	if err != nil {
 		return nil, err
 	}