Added Tip abd Mortality to Tx Options.

Author: markopoloparadox

examples/data_submission.go

@@ -55,6 +55,7 @@ func RunDataSubmission() {
 	// Transaction Details
 	fmt.Println(fmt.Sprintf(`Block Hash: %v, Block Index: %v, Tx Hash: %v, Tx Index: %v`, res.BlockHash.ToHexWith0x(), res.BlockNumber, res.TxHash.ToHexWith0x(), res.TxIndex))
 
+	AssertTrue(res.Events.IsSome(), "Failed to decode events.")
 	events = res.Events.Unwrap()
 	event2 := SDK.EventFindFirst(events, daPallet.EventDataSubmitted{}).Unwrap()
 

examples/transaction_options.go

@@ -8,20 +8,24 @@ import (
 )
 
 func RunTransactionOptions() {
-	runAppId()
-	runNonce()
+	RunTransactionOptionsAppId()
+	RunTransactionOptionsNonce()
+	RunTransactionOptionsMortality()
+	RunTransactionOptionsTip()
 
 	fmt.Println("RunTransactionOptions finished correctly.")
 }
 
-func runAppId() {
+func RunTransactionOptionsAppId() {
 	sdk, err := SDK.NewSDK(SDK.LocalEndpoint)
 	PanicOnError(err)
 
-	// Setting AppId and Executing Transaction
+	// Setting AppId
 	appId := uint32(5)
-	tx := sdk.Tx.DataAvailability.SubmitData([]byte("Hello World"))
 	options := SDK.NewTransactionOptions().WithAppId(appId)
+
+	// Executing Transaction
+	tx := sdk.Tx.DataAvailability.SubmitData([]byte("Hello World"))
 	res, err := tx.ExecuteAndWatchInclusion(SDK.Account.Alice(), options)
 	PanicOnError(err)
 
@@ -34,9 +38,11 @@ func runAppId() {
 	genTx := block.TransactionByHash(res.TxHash).UnsafeUnwrap()
 	foundAppId := genTx.Signed().UnsafeUnwrap().AppId
 	AssertEq(appId, foundAppId, "App Ids are not the same")
+
+	fmt.Println("RunTransactionOptionsAppId finished correctly.")
 }
 
-func runNonce() {
+func RunTransactionOptionsNonce() {
 	sdk, err := SDK.NewSDK(SDK.LocalEndpoint)
 	PanicOnError(err)
 
@@ -64,4 +70,56 @@ func runNonce() {
 	newNonce, err := SDK.Account.Nonce(sdk.Client, metadata.NewAccountIdFromKeyPair(acc))
 	PanicOnError(err)
 	AssertEq(newNonce, currentNonce+1, "New nonce and old nonce + 1 are not the same.")
+
+	fmt.Println("RunTransactionOptionsNonce finished correctly.")
+}
+
+func RunTransactionOptionsMortality() {
+	sdk, err := SDK.NewSDK(SDK.LocalEndpoint)
+	PanicOnError(err)
+
+	// Setting Mortality
+	mortality := uint32(16)
+	options := SDK.NewTransactionOptions().WithMortality(mortality).WithAppId(1)
+
+	// Executing Transaction
+	tx := sdk.Tx.DataAvailability.SubmitData([]byte("Hello World"))
+	res, err := tx.ExecuteAndWatchInclusion(SDK.Account.Alice(), options)
+	PanicOnError(err)
+	AssertTrue(res.IsSuccessful().Unwrap(), "Transaction is supposed to succeed")
+
+	block, err := SDK.NewBlock(sdk.Client, res.BlockHash)
+	PanicOnError(err)
+
+	// Checking if the Mortality is the same as the one expected
+	genTx := block.TransactionByHash(res.TxHash).UnsafeUnwrap()
+	actualMortality := uint32(genTx.Signed().UnsafeUnwrap().Era.Period)
+	AssertEq(actualMortality, mortality, "Moartalities are not the same.")
+
+	fmt.Println("RunTransactionOptionsMortality finished correctly.")
+}
+
+func RunTransactionOptionsTip() {
+	sdk, err := SDK.NewSDK(SDK.LocalEndpoint)
+	PanicOnError(err)
+
+	// Setting Tip
+	tip := SDK.OneAvail()
+	options := SDK.NewTransactionOptions().WithTip(tip).WithAppId(1)
+
+	// Executing Transaction
+	tx := sdk.Tx.DataAvailability.SubmitData([]byte("Hello World"))
+	res, err := tx.ExecuteAndWatchInclusion(SDK.Account.Alice(), options)
+	PanicOnError(err)
+	AssertTrue(res.IsSuccessful().Unwrap(), "Transaction is supposed to succeed")
+
+	block, err := SDK.NewBlock(sdk.Client, res.BlockHash)
+	PanicOnError(err)
+
+	// Checking if the Tip is the same as the one expected
+	genTx := block.TransactionByHash(res.TxHash).UnsafeUnwrap()
+	actualTip := genTx.Signed().UnsafeUnwrap().Tip
+	AssertEq(metadata.Balance{Value: actualTip}, tip, "Tips are not the same.")
+
+	fmt.Println("RunTransactionOptionsTip finished correctly.")
 }

main.go

@@ -1,8 +1,6 @@
 package main
 
-import (
-	"github.com/availproject/avail-go-sdk/examples"
-)
+import "github.com/availproject/avail-go-sdk/examples"
 
 func main() {
 	examples.Run()

primitives/extrinsics_decoded.go

@@ -3,6 +3,7 @@ package primitives
 import (
 	"errors"
 
+	"github.com/itering/scale.go/utiles/uint128"
 	"golang.org/x/crypto/blake2b"
 )
 
@@ -18,6 +19,8 @@ type DecodedExtrinsicSigned struct {
 	Signature MultiSignature
 	Nonce     uint32
 	AppId     uint32
+	Tip       uint128.Uint128
+	Era       Era
 }
 
 func NewDecodedExtrinsic(extrinsic EncodedExtrinsic, txIndex uint32) (DecodedExtrinsic, error) {
@@ -67,6 +70,8 @@ func NewDecodedExtrinsic(extrinsic EncodedExtrinsic, txIndex uint32) (DecodedExt
 			Signature: multiSignature,
 			Nonce:     extra.Nonce,
 			AppId:     extra.AppId,
+			Tip:       extra.Tip,
+			Era:       extra.Era,
 		}
 
 		signedPart.Set(signedData)

primitives/extrinsics_payload.go

@@ -50,14 +50,14 @@ func (this *Call) Decode(decoder *Decoder) error {
 
 // Do not change the order of field members.
 type Era struct {
-	period uint64
-	phase  uint64
+	Period uint64
+	Phase  uint64
 }
 
 func (this *Era) EncodeTo(dest *string) {
-	quantizeFactor := math.Max(float64(this.period>>12), 1)
-	trailingZeros := bits.TrailingZeros16(uint16(this.period))
-	encoded := uint16(float64(this.phase)/quantizeFactor)<<4 | uint16(math.Min(15, math.Max(1, float64(trailingZeros-1))))
+	quantizeFactor := math.Max(float64(this.Period>>12), 1)
+	trailingZeros := bits.TrailingZeros16(uint16(this.Period))
+	encoded := uint16(float64(this.Phase)/quantizeFactor)<<4 | uint16(math.Min(15, math.Max(1, float64(trailingZeros-1))))
 
 	first := byte(encoded & 0xff)
 	second := byte(encoded >> 8)
@@ -87,9 +87,9 @@ func (this *Era) Decode(decoder *Decoder) error {
 	trailingZeros := uint16(encoded&0xF) + 1 // Lower 4 bits + 1
 	quantizedPhase := encoded >> 4           // Upper 12 bits
 
-	quantizeFactor := math.Max(float64(this.period>>12), 1)
-	this.phase = uint64(float64(quantizedPhase) * quantizeFactor)
-	this.period = uint64(uint16(1 << trailingZeros))
+	quantizeFactor := math.Max(float64(this.Period>>12), 1)
+	this.Phase = uint64(float64(quantizedPhase) * quantizeFactor)
+	this.Period = uint64(uint16(1 << trailingZeros))
 
 	return nil
 }
@@ -109,8 +109,8 @@ func NewEra(period uint64, blockNumber uint64) Era {
 	quantized_phase := float64(phase) / quantize_factor * quantize_factor
 
 	return Era{
-		period: calPeriod,
-		phase:  uint64(quantized_phase),
+		Period: calPeriod,
+		Phase:  uint64(quantized_phase),
 	}
 }
 

sdk/transaction_options.go

@@ -3,20 +3,23 @@ package sdk
 import (
 	"github.com/itering/scale.go/utiles/uint128"
 
-	"math/big"
-
+	"github.com/availproject/avail-go-sdk/metadata"
 	prim "github.com/availproject/avail-go-sdk/primitives"
 )
 
 type TransactionOptions struct {
-	AppId prim.Option[uint32]
-	Nonce prim.Option[uint32]
+	AppId     prim.Option[uint32]
+	Nonce     prim.Option[uint32]
+	Mortality prim.Option[uint32]
+	Tip       prim.Option[metadata.Balance]
 }
 
 func NewTransactionOptions() TransactionOptions {
 	return TransactionOptions{
-		AppId: prim.NewNone[uint32](),
-		Nonce: prim.NewNone[uint32](),
+		AppId:     prim.NewNone[uint32](),
+		Nonce:     prim.NewNone[uint32](),
+		Mortality: prim.NewNone[uint32](),
+		Tip:       prim.NewNone[metadata.Balance](),
 	}
 }
 
@@ -30,6 +33,16 @@ func (this TransactionOptions) WithNonce(value uint32) TransactionOptions {
 	return this
 }
 
+func (this TransactionOptions) WithMortality(value uint32) TransactionOptions {
+	this.Mortality = prim.NewSome(value)
+	return this
+}
+
+func (this TransactionOptions) WithTip(value metadata.Balance) TransactionOptions {
+	this.Tip = prim.NewSome(value)
+	return this
+}
+
 func (this *TransactionOptions) ToPrimitive(client *Client, accountAddress string) (prim.Extra, prim.Additional, error) {
 	genesisHash, err := client.Rpc.ChainSpec.V1GenesisHash()
 	if err != nil {
@@ -59,7 +72,7 @@ func (this *TransactionOptions) ToPrimitive(client *Client, accountAddress strin
 
 	extra := prim.Extra{}
 	extra.AppId = this.AppId.UnwrapOr(uint32(0))
-	extra.Tip = uint128.FromBig(big.NewInt(0))
+	extra.Tip = this.Tip.UnwrapOr(metadata.Balance{Value: uint128.Zero}).Value
 	if this.Nonce.IsNone() {
 		extra.Nonce, err = client.Rpc.System.AccountNextIndex(accountAddress)
 		if err != nil {
@@ -68,7 +81,7 @@ func (this *TransactionOptions) ToPrimitive(client *Client, accountAddress strin
 	} else {
 		extra.Nonce = this.Nonce.Unwrap()
 	}
-	extra.Era = prim.NewEra(32, uint64(forBlockNumber))
+	extra.Era = prim.NewEra(uint64(this.Mortality.UnwrapOr(32)), uint64(forBlockNumber))
 
 	return extra, additional, nil
 }
@@ -84,7 +97,7 @@ func RegenerateEra(client *Client, extra *prim.Extra, additional *prim.Additiona
 	}
 
 	additional.ForkHash = forkHash
-	extra.Era = prim.NewEra(32, uint64(header.Number))
+	extra.Era = prim.NewEra(extra.Era.Period, uint64(header.Number))
 
 	return nil
 }