Added PaymentQueryFeeDetails rpc

Author: markopoloparadox

main.go

@@ -1,9 +1,13 @@
 package main
 
-import (
-	"github.com/availproject/avail-go-sdk/examples"
-)
+import ()
 
 func main() {
-	examples.Run()
+
+}
+
+func panic2(err error) {
+	if err != nil {
+		panic(err)
+	}
 }

metadata/types.go

@@ -46,7 +46,14 @@ func (this Balance) ToHuman() string {
 		var trailing = removeTrailingZeros(stringValue)
 		if trailing == "" {
 			result += "0"
+		} else {
+			missingPlaces := 18 - len(stringValue)
+
+			for i := 0; i < missingPlaces; i++ {
+				result += "0"
+			}
 		}
+
 		return result + trailing + " Avail"
 	}
 
@@ -1585,3 +1592,9 @@ type AddressedMessage struct {
 	DestinationDomain uint32 `scale:"compact"`
 	Id                uint64 `scale:"compact"`
 }
+
+type InclusionFee struct {
+	BaseFee           Balance
+	LenFee            Balance
+	AdjustedWeightFee Balance
+}

sdk/rpc.go

@@ -1,6 +1,7 @@
 package sdk
 
 import (
+	"fmt"
 	"strconv"
 
 	prim "github.com/availproject/avail-go-sdk/primitives"
@@ -14,6 +15,7 @@ type RPC struct {
 	ChainSpec chainSpecRPC
 	Kate      kateRPC
 	Author    authorRPC
+	Payment   paymentRPC
 }
 
 func newRPC(client *Client) RPC {
@@ -25,6 +27,7 @@ func newRPC(client *Client) RPC {
 		ChainSpec: chainSpecRPC{client: client},
 		Kate:      kateRPC{client: client},
 		Author:    authorRPC{client: client},
+		Payment:   paymentRPC{client: client},
 	}
 }
 
@@ -36,6 +39,25 @@ func (this *RPCParams) Add(value string) {
 	this.Values = append(this.Values, value)
 }
 
+func (this *RPCParams) AddByteSlice(value []byte) {
+	if len(value) == 0 {
+		return
+	}
+
+	res := "["
+	for i, elem := range value {
+		res += fmt.Sprintf("%v", elem)
+
+		if i < (len(value) - 1) {
+			res += ","
+		}
+	}
+
+	res = res + "]"
+
+	this.Values = append(this.Values, res)
+}
+
 func (this *RPCParams) AddH256(value prim.H256) {
 	this.Add(value.ToRpcParam())
 }

sdk/rpc_payment.go

@@ -0,0 +1,86 @@
+package sdk
+
+import (
+	"encoding/json"
+	"errors"
+	"math/big"
+	"strings"
+
+	"github.com/availproject/avail-go-sdk/metadata"
+	prim "github.com/availproject/avail-go-sdk/primitives"
+)
+
+type paymentRPC struct {
+	client *Client
+}
+
+func (this *paymentRPC) QueryFeeDetails(extrinsic string, at prim.Option[prim.H256]) (metadata.InclusionFee, error) {
+	var params = &RPCParams{}
+
+	if !strings.HasPrefix(extrinsic, "0x") {
+		extrinsic = "0x" + extrinsic
+	}
+
+	params.Add("\"" + extrinsic + "\"")
+	if at.IsSome() {
+		params.AddH256(at.Unwrap())
+	}
+
+	rawJson, err := this.client.Request("payment_queryFeeDetails", params.Build())
+	if err != nil {
+		return metadata.InclusionFee{}, err
+	}
+
+	var mappedData map[string]interface{}
+	if err := json.Unmarshal([]byte(rawJson), &mappedData); err != nil {
+		return metadata.InclusionFee{}, err
+	}
+
+	if mappedData["inclusionFee"] == nil {
+		return metadata.InclusionFee{}, errors.New("Failed to find inclusionFee")
+	}
+
+	jsonData := mappedData["inclusionFee"].(map[string]interface{})
+	if jsonData["adjustedWeightFee"] == nil {
+		return metadata.InclusionFee{}, errors.New("Failed to find adjustedWeightFee")
+	}
+
+	if jsonData["baseFee"] == nil {
+		return metadata.InclusionFee{}, errors.New("Failed to find baseFee")
+	}
+
+	if jsonData["lenFee"] == nil {
+		return metadata.InclusionFee{}, errors.New("Failed to find lenFee")
+	}
+
+	res := metadata.InclusionFee{}
+
+	{
+		lenFeeString := jsonData["lenFee"].(string)
+		v := big.Int{}
+		if _, ok := v.SetString(lenFeeString[2:], 16); !ok {
+			return metadata.InclusionFee{}, errors.New("Failed to convert lenFee")
+		}
+		res.LenFee = metadata.NewBalanceFromBigInt(&v)
+	}
+
+	{
+		baseFeeString := jsonData["baseFee"].(string)
+		v := big.Int{}
+		if _, ok := v.SetString(baseFeeString[2:], 16); !ok {
+			return metadata.InclusionFee{}, errors.New("Failed to convert baseFee")
+		}
+		res.BaseFee = metadata.NewBalanceFromBigInt(&v)
+	}
+
+	{
+		adjustedWeightFeeString := jsonData["adjustedWeightFee"].(string)
+		v := big.Int{}
+		if _, ok := v.SetString(adjustedWeightFeeString[2:], 16); !ok {
+			return metadata.InclusionFee{}, errors.New("Failed to convert adjustedWeightFee")
+		}
+		res.AdjustedWeightFee = metadata.NewBalanceFromBigInt(&v)
+	}
+
+	return res, err
+}

sdk/rpc_state.go

@@ -71,3 +71,15 @@ func (this *stateRPC) GetEvents(at prim.Option[prim.H256]) (string, error) {
 
 	return this.client.Request("state_getStorage", params.Build())
 }
+
+/* func (this *stateRPC) Call(method string, data string, at prim.Option[prim.H256]) (string, error) {
+	params := RPCParams{}
+	params.Add("\"" + method + "\"")
+	params.Add("\"" + data + "\"")
+	if at.IsSome() {
+		params.AddH256(at.Unwrap())
+	}
+
+	return this.client.Request("state_call", params.Build())
+}
+*/

sdk/transaction.go

@@ -19,31 +19,44 @@ const Finalization = uint8(0)
 const Inclusion = uint8(1)
 
 type Transaction struct {
-	Client  *Client
+	client  *Client
 	Payload metadata.Payload
 }
 
 func NewTransaction(client *Client, payload metadata.Payload) Transaction {
 	return Transaction{
-		Client:  client,
+		client:  client,
 		Payload: payload,
 	}
 }
 
 func (this *Transaction) Execute(account subkey.KeyPair, options TransactionOptions) (prim.H256, error) {
-	return TransactionSignAndSend(this.Client, account, this.Payload, options)
+	return TransactionSignAndSend(this.client, account, this.Payload, options)
 }
 
 func (this *Transaction) ExecuteAndWatch(account subkey.KeyPair, waitFor uint8, blockTimeout uint32, options TransactionOptions) (TransactionDetails, error) {
-	return TransactionSignSendWatch(this.Client, account, this.Payload, waitFor, blockTimeout, options)
+	return TransactionSignSendWatch(this.client, account, this.Payload, waitFor, blockTimeout, options)
 }
 
 func (this *Transaction) ExecuteAndWatchFinalization(account subkey.KeyPair, options TransactionOptions) (TransactionDetails, error) {
-	return TransactionSignSendWatch(this.Client, account, this.Payload, Finalization, 5, options)
+	return TransactionSignSendWatch(this.client, account, this.Payload, Finalization, 5, options)
 }
 
 func (this *Transaction) ExecuteAndWatchInclusion(account subkey.KeyPair, options TransactionOptions) (TransactionDetails, error) {
-	return TransactionSignSendWatch(this.Client, account, this.Payload, Inclusion, 3, options)
+	return TransactionSignSendWatch(this.client, account, this.Payload, Inclusion, 3, options)
+}
+
+func (this *Transaction) PaymentQueryFeeDetails(account subkey.KeyPair, options TransactionOptions) (metadata.InclusionFee, error) {
+	extra, additional, err := options.ToPrimitive(this.client, account.SS58Address(42))
+	if err != nil {
+		return metadata.InclusionFee{}, err
+	}
+	tx, err := prim.CreateSigned(this.Payload.Call, extra, additional, account)
+	if err != nil {
+		return metadata.InclusionFee{}, err
+	}
+
+	return this.client.Rpc.Payment.QueryFeeDetails(tx.Value, prim.NewNone[prim.H256]())
 }
 
 func TransactionSignAndSend(client *Client, account subkey.KeyPair, payload metadata.Payload, options TransactionOptions) (prim.H256, error) {