Fix/refactor zboxcore mobilesdk fixes

core/client/init_node.go

@@ -88,7 +88,7 @@ func (n *Node) ShouldUpdateNetwork() (bool, *conf.Network, error) {
 	if err != nil {
 		return false, nil, err
 	}
-	network, err := GetNetwork(n.clientCtx)
+	network, err := GetNetwork(n.clientCtx, cfg.BlockWorker)
 	if err != nil {
 		logging.Error("Failed to get network details ", zap.Error(err), zap.String("block_worker", cfg.BlockWorker))
 		return false, nil, err
@@ -126,10 +126,7 @@ func Init(ctx context.Context, cfg conf.Config) error {
 	// set default value for options if unset
 	setOptionsDefaultValue(&cfg)
 
-	//init packages
-	conf.InitClientConfig(&cfg)
-
-	network, err := GetNetwork(ctx)
+	network, err := GetNetwork(ctx, cfg.BlockWorker)
 	if err != nil {
 		logging.Error("Failed to get network details ", zap.Error(err), zap.Any("block_worker", cfg.BlockWorker))
 		return err
@@ -144,6 +141,8 @@ func Init(ctx context.Context, cfg conf.Config) error {
 		clientCtx:    ctx,
 	}
 
+	//init packages
+	conf.InitClientConfig(&cfg)
 	InitCache(nodeClient.sharders)
 
 	// update Network periodically
@@ -181,12 +180,8 @@ func GetNode() (*Node, error) {
 }
 
 // GetNetwork gets current network details from 0chain network.
-func GetNetwork(ctx context.Context) (*conf.Network, error) {
-	cfg, err := conf.GetClientConfig()
-	if err != nil {
-		return nil, err
-	}
-	networkUrl := cfg.BlockWorker + "/network"
+func GetNetwork(ctx context.Context, blockWorker string) (*conf.Network, error) {
+	networkUrl := blockWorker + "/network"
 	networkGetCtx, networkGetCancelCtx := context.WithTimeout(ctx, 60*time.Second)
 	defer networkGetCancelCtx()
 	req, err := util.NewHTTPGetRequestContext(networkGetCtx, networkUrl)

core/version/version.go

@@ -2,4 +2,4 @@
 
 package version
 
-const VERSIONSTR = "v1.17.9-218-g7b354b71"
+const VERSIONSTR = "v1.17.9-237-g90b641fe"

mobilesdk/sdk/sdk.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	coreTransaction "github.com/0chain/gosdk/core/transaction"
 	"math"
 	"strconv"
 	"strings"
@@ -71,8 +72,10 @@ func Init(chainConfigJson string) error {
 	cfg := conf.Config{}
 	err := json.Unmarshal([]byte(chainConfigJson), &cfg)
 	if err != nil {
-		return err
+		return errors.WithMessage(err, "failed to unmarshal chain config")
 	}
+	l.Logger.Info("InitSDK chain config")
+	l.Logger.Info(cfg)
 	return client.Init(context.Background(), cfg)
 }
 
@@ -358,6 +361,11 @@ func (s *StorageSDK) GetVersion() string {
 	return version.VERSIONSTR
 }
 
+// GetVersion getting current version for gomobile lib
+func GetVersion() string {
+	return version.VERSIONSTR
+}
+
 // UpdateAllocation update allocation settings with new expiry and size
 //   - size: size of space reserved on blobbers
 //   - extend: extend allocation
@@ -385,6 +393,17 @@ func (s *StorageSDK) GetBlobbersList() (string, error) {
 	return string(retBytes), nil
 }
 
+// GetStorageConfig get storage config
+// configType: storage_sc_config, miners_sc_globals, miner_sc_configs
+func GetStorageConfig(configType string) ([]byte, error) {
+	configBytes, err := coreTransaction.GetConfig(configType)
+	retBytes, err := json.Marshal(configBytes)
+	if err != nil {
+		return nil, err
+	}
+	return retBytes, nil
+}
+
 // GetAllocations return back list of allocations for the wallet
 // Extracted from main method, bcz of class fields
 func GetAllocations() (string, error) {

mobilesdk/zcn/execute_transactions.go

@@ -0,0 +1,238 @@
+package zcn
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/0chain/gosdk/zcncore"
+)
+
+// MinerStakePoolLock locks the stake pool for the miner.
+// # Inputs
+//   - providerId: provider id
+//   - lock: lock amount
+func MinerStakePoolLock(providerId string, lock int64) ([]byte, error) {
+	if tokenValidation(lock) != nil {
+		return nil, tokenValidation(lock)
+	}
+
+	_, _, _, txn, err := zcncore.MinerSCLock(providerId, zcncore.ProviderMiner, uint64(lock))
+
+	if err != nil {
+		return nil, errors.New("Error in MinerSCLock: " + err.Error())
+	}
+
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// MinerStakePoolUnlock unlocks the stake pool for the miner.
+// # Inputs
+//   - providerId: provider id
+func MinerStakePoolUnlock(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.MinerSCUnlock(providerId, zcncore.ProviderMiner)
+
+	if err != nil {
+		return nil, errors.New("Error in MinerSCUnlock: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// MinerCollectReward collects the reward from the miner smart contract.
+// # Inputs
+//   - providerId: provider id
+func MinerCollectReward(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.MinerSCCollectReward(providerId, zcncore.ProviderMiner)
+
+	if err != nil {
+		return nil, errors.New("Error in MinerSCCollectReward: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// BlobberStakePoolLock locks the stake pool for the blobber.
+// # Inputs
+//   - providerId: provider id
+//   - lock: lock amount
+func BlobberStakePoolLock(providerId string, lock int64) ([]byte, error) {
+	if tokenValidation(lock) != nil {
+		return nil, tokenValidation(lock)
+	}
+
+	_, _, _, txn, err := zcncore.StorageSCStakePoolLock(providerId, zcncore.ProviderBlobber, uint64(lock))
+
+	if err != nil {
+		return nil, errors.New("Error in BlobberSCLock: " + err.Error())
+	}
+
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// BlobberStakePoolUnlock unlocks the stake pool for the blobber.
+// # Inputs
+//   - providerId: provider id
+func BlobberStakePoolUnlock(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.StorageSCStakePoolUnlock(providerId, zcncore.ProviderBlobber)
+
+	if err != nil {
+		return nil, errors.New("Error in BlobberSCUnlock: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// BlobberCollectReward locks the stake pool for the blobber.
+// # Inputs
+//   - providerId: provider id
+func BlobberCollectReward(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.StorageSCCollectReward(providerId, zcncore.ProviderBlobber)
+
+	if err != nil {
+		return nil, errors.New("Error in BlobberSCCollectReward: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// SharderStakePoolLock locks the stake pool for the sharder.
+// # Inputs
+//   - providerId: provider id
+//   - lock: lock amount
+func SharderStakePoolLock(providerId string, lock int64) ([]byte, error) {
+	if tokenValidation(lock) != nil {
+		return nil, tokenValidation(lock)
+	}
+
+	_, _, _, txn, err := zcncore.MinerSCLock(providerId, zcncore.ProviderSharder, uint64(lock))
+
+	if err != nil {
+		return nil, errors.New("Error in SharderSCLock: " + err.Error())
+	}
+
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// SharderStakePoolUnlock unlocks the stake pool for the sharder.
+// # Inputs
+//   - providerId: provider id
+func SharderStakePoolUnlock(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.MinerSCUnlock(providerId, zcncore.ProviderSharder)
+
+	if err != nil {
+		return nil, errors.New("Error in SharderSCUnlock: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+func SharderCollectReward(providerId string) ([]byte, error) {
+	_, _, _, txn, err := zcncore.MinerSCCollectReward(providerId, zcncore.ProviderSharder)
+
+	if err != nil {
+		return nil, errors.New("Error in SharderSCCollectReward: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+func SendZCN(senderClientId string, tokens int64, description string) ([]byte, error) {
+	if tokenValidation(tokens) != nil {
+		return nil, tokenValidation(tokens)
+
+	}
+
+	_, _, _, txn, err := zcncore.Send(senderClientId, uint64(tokens), description)
+
+	if err != nil {
+		return nil, errors.New("Error in SendZCN: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+
+}
+
+// Faucet sends tokens to the user.
+// # Inputs
+//   - tokens: tokens to send
+//   - input: input
+func Faucet(tokens int64, input string) ([]byte, error) {
+	if tokenValidation(tokens) != nil {
+		return nil, tokenValidation(tokens)
+	}
+
+	_, _, _, txn, err := zcncore.Faucet(uint64(tokens), input)
+
+	if err != nil {
+		return nil, errors.New("Error in Faucet: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+// VerifyTransaction verifies the transaction.
+// # Inputs
+//   - hash: hash of the transaction
+func VerifyTransaction(hash string) ([]byte, error) {
+	txn, err := zcncore.VerifyTransaction(hash)
+	if err != nil {
+		return nil, errors.New("Error in VerifyTransaction: " + err.Error())
+	}
+	byteTxn, err := json.Marshal(txn)
+	if err != nil {
+		return nil, errors.New("Error in Encoding txn: " + err.Error())
+	}
+	return byteTxn, nil
+}
+
+func tokenValidation(tokens int64) error {
+	if tokens <= 0 {
+		return errors.New("negative or zero tokens not allowed")
+	}
+	return nil
+}
+
+func getProviderType(providerType int) zcncore.Provider {
+	switch providerType {
+	case 0:
+		return zcncore.ProviderMiner
+	case 1:
+		return zcncore.ProviderSharder
+	}
+	return zcncore.ProviderMiner
+}

zboxcore/sdk/sdk.go

@@ -465,6 +465,19 @@ func getBlobbersInternal(active, stakable bool, limit, offset int) (bs []*Blobbe
 	return wrap.Nodes, nil
 }
 
+func GetBlobbersPaged(active, stakable bool, limit, offset int) ([]*Blobber, error) {
+	if !client.IsSDKInitialized() {
+		return nil, sdkNotInitialized
+	}
+
+	blobbers, err := getBlobbersInternal(active, stakable, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+
+	return blobbers, nil
+}
+
 // GetBlobbers returns list of blobbers.
 //   - active: if true then only active blobbers are returned
 //   - stakable: if true then only stakable blobbers are returned

zcncore/execute_transactions.go

@@ -87,6 +87,26 @@ func MinerSCKill(providerId string, providerType Provider) (hash, out string, no
 
 }
 
+func StorageSCStakePoolLock(providerId string, providerType Provider, lock uint64) (hash, out string, nonce int64, txn *transaction.Transaction, err error) {
+	return transaction.SmartContractTxnValue(StorageSmartContractAddress, transaction.SmartContractTxnData{
+		Name: transaction.STORAGESC_STAKE_POOL_LOCK,
+		InputArgs: &stakePoolRequest{
+			ProviderID:   providerId,
+			ProviderType: providerType,
+		},
+	}, lock)
+}
+
+func StorageSCStakePoolUnlock(providerId string, providerType Provider) (hash, out string, nonce int64, txn *transaction.Transaction, err error) {
+	return transaction.SmartContractTxn(StorageSmartContractAddress, transaction.SmartContractTxnData{
+		Name: transaction.STORAGESC_STAKE_POOL_UNLOCK,
+		InputArgs: &stakePoolRequest{
+			ProviderID:   providerId,
+			ProviderType: providerType,
+		},
+	})
+}
+
 func StorageSCCollectReward(providerId string, providerType Provider) (hash, out string, nonce int64, txn *transaction.Transaction, err error) {
 	return transaction.SmartContractTxn(StorageSmartContractAddress, transaction.SmartContractTxnData{
 		Name: transaction.STORAGESC_COLLECT_REWARD,
@@ -215,3 +235,7 @@ func Faucet(tokens uint64, input string) (hash, out string, nonce int64, txn *tr
 		InputArgs: input,
 	}, tokens)
 }
+
+func VerifyTransaction(hash string) (txn *transaction.Transaction, err error) {
+	return transaction.VerifyTransaction(hash)
+}