feat: fetch the balance of the wallet before trying to continue (#1302)

data_layer/avail/avail.go

@@ -8,15 +8,19 @@ import (
 	cosmossdkmath "cosmossdk.io/math"
 	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
 	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
-	availtypes "github.com/centrifuge/go-substrate-rpc-client/v4/types"
 	cosmossdktypes "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/go-bip39"
 
+	prim "github.com/availproject/avail-go-sdk/primitives"
+	"github.com/availproject/avail-go-sdk/sdk"
 	"github.com/dymensionxyz/roller/cmd/consts"
 	"github.com/dymensionxyz/roller/utils/errorhandling"
 	"github.com/dymensionxyz/roller/utils/keys"
 	"github.com/dymensionxyz/roller/utils/roller"
 	"github.com/pterm/pterm"
+
+	syPallet "github.com/availproject/avail-go-sdk/metadata/pallets/system"
+	"github.com/availproject/avail-go-sdk/primitives"
 )
 
 const (
@@ -100,6 +104,16 @@ func NewAvail(root string) *Avail {
 			panic(fmt.Errorf("Avail addr need to be fund!"))
 		}
 
+		insufficientBalances, err := availConfig.CheckDABalance()
+		if err != nil {
+			pterm.Error.Println("failed to check balance", err)
+		}
+
+		err = keys.PrintInsufficientBalancesIfAny(insufficientBalances)
+		if err != nil {
+			pterm.Error.Println("failed to check insufficient balances: ", err)
+		}
+
 		daData, exists := consts.DaNetworks[daNetwork]
 		if !exists {
 			panic(fmt.Errorf("DA network configuration not found for: %s", daNetwork))
@@ -147,12 +161,12 @@ func (a *Avail) CheckDABalance() ([]keys.NotFundedAddressData, error) {
 
 	exp := new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)
 	required := new(big.Int).Mul(big.NewInt(requiredAVL), exp)
-	if required.Cmp(balance.Int) > 0 {
+	if required.Cmp(balance) > 0 {
 		return []keys.NotFundedAddressData{
 			{
 				KeyName:         a.GetKeyName(),
 				Address:         a.AccAddress,
-				CurrentBalance:  balance.Int,
+				CurrentBalance:  balance,
 				RequiredBalance: required,
 				Denom:           consts.Denoms.Avail,
 				Network:         string(consts.Avail),
@@ -162,39 +176,39 @@ func (a *Avail) CheckDABalance() ([]keys.NotFundedAddressData, error) {
 	return nil, nil
 }
 
-func (a *Avail) getBalance() (availtypes.U128, error) {
-	if a.client == nil {
-		client, err := gsrpc.NewSubstrateAPI(a.RpcEndpoint)
-		if err != nil {
-			return availtypes.U128{}, err
-		}
-		a.client = client
-	}
-	var res availtypes.U128
-	meta, err := a.client.RPC.State.GetMetadataLatest()
+func (a *Avail) getBalance() (*big.Int, error) {
+	// Initialize the SDK
+	sdk, err := sdk.NewSDK(a.RpcEndpoint)
 	if err != nil {
-		return res, err
+		return nil, fmt.Errorf("Failed to initialize SDK: %v", err)
 	}
 
-	keyringPair, err := signature.KeyringPairFromSecret(a.Mnemonic, keyringNetworkID)
+	// Get the latest block hash
+	latestBlockHash, err := sdk.Client.BestBlockHash()
 	if err != nil {
-		return res, err
+		return nil, fmt.Errorf("Failed to get latest block hash: %v", err)
 	}
-	key, err := availtypes.CreateStorageKey(meta, "System", "Account", keyringPair.PublicKey)
+
+	// Initialize the block storage
+	blockStorage, err := sdk.Client.StorageAt(prim.Some(latestBlockHash))
 	if err != nil {
-		return res, err
+		return nil, fmt.Errorf("Failed to get block storage: %v", err)
 	}
 
-	var accountInfo availtypes.AccountInfo
-	ok, err := a.client.RPC.State.GetStorageLatest(key, &accountInfo)
+	// Create the account ID
+	accountId, err := primitives.NewAccountIdFromAddress(a.AccAddress)
 	if err != nil {
-		return res, err
+		return nil, fmt.Errorf("Failed to convert address: %v", err)
 	}
-	if !ok {
-		return res, fmt.Errorf("account %s not found", keyringPair.Address)
+
+	// Fetch the account data
+	storage := syPallet.StorageAccount{}
+	val, err := storage.Fetch(&blockStorage, accountId)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to fetch account: %v", err)
 	}
 
-	return accountInfo.Data.Free, nil
+	return val.Value.AccountData.Free.Value.Big(), nil
 }
 
 func (a *Avail) GetStartDACmd() *exec.Cmd {
@@ -206,12 +220,13 @@ func (a *Avail) GetDAAccData(cfg roller.RollappConfig) ([]keys.AccountData, erro
 	if err != nil {
 		return nil, err
 	}
+
 	return []keys.AccountData{
 		{
 			Address: a.AccAddress,
 			Balance: cosmossdktypes.Coin{
 				Denom:  consts.Denoms.Avail,
-				Amount: cosmossdkmath.NewIntFromBigInt(balance.Int),
+				Amount: cosmossdkmath.NewIntFromBigInt(balance),
 			},
 		},
 	}, nil