func (t FlowTransactionBuilder) RunE() ([]flow.Event, error) {
	if t.MainSigner == nil {
		return nil, fmt.Errorf("%v You need to set the main signer", emoji.PileOfPoo)
	}
	codeFileName := fmt.Sprintf("./transactions/%s.cdc", t.FileName)
	code, err := t.getContractCode(codeFileName)
	if err != nil {
		return nil, err
	}
	signers := t.PayloadSigners
	signers = append(signers, t.MainSigner)
	signerKeyIndex := t.MainSigner.Key().Index()
	var authorizers []flow.Address
	for _, signer := range signers {
		authorizers = append(authorizers, signer.Address())
	}
	tx, err := t.GoWithTheFlow.Services.Transactions.Build(
		t.MainSigner.Address(),
		authorizers,
		t.MainSigner.Address(),
		signerKeyIndex,
		code,
		codeFileName,
		t.GasLimit,
		t.Arguments,
		t.GoWithTheFlow.Network,
	)
	if err != nil {
		return nil, err
	}
	for _, signer := range signers {
		err = tx.SetSigner(signer)
		if err != nil {
			return nil, err
		}
		tx, err = tx.Sign()
		if err != nil {
			return nil, err
		}
	}
	t.GoWithTheFlow.Logger.Info(fmt.Sprintf("Transaction ID: %s", tx.FlowTransaction().ID()))
	t.GoWithTheFlow.Logger.StartProgress("Sending transaction...")
	defer t.GoWithTheFlow.Logger.StopProgress()
	txBytes := []byte(fmt.Sprintf("%x", tx.FlowTransaction().Encode()))
	_, res, err := t.GoWithTheFlow.Services.Transactions.SendSigned(txBytes)
	if err != nil {
		return nil, err
	}
	if res.Error != nil {
		return nil, res.Error
	}
	t.GoWithTheFlow.Logger.Info(fmt.Sprintf("%v Transaction %s successfully applied\n", emoji.OkHand, t.FileName))
	return res.Events, nil
}
RunE runs returns error
package gwtf
import (
	"fmt"
	"log"
	"os"
	"time"
	"github.com/araddon/dateparse"
	"github.com/enescakir/emoji"
	"github.com/onflow/cadence"
	"github.com/onflow/flow-cli/pkg/flowkit"
	"github.com/onflow/flow-go-sdk"
)
func (f *GoWithTheFlow) TransactionFromFile(filename string) FlowTransactionBuilder {
	return FlowTransactionBuilder{
		GoWithTheFlow:  f,
		FileName:       filename,
		MainSigner:     nil,
		Arguments:      []cadence.Value{},
		PayloadSigners: []*flowkit.Account{},
		GasLimit:       9999,
	}
}
func (f *GoWithTheFlow) Transaction(content string) FlowTransactionBuilder {
	return FlowTransactionBuilder{
		GoWithTheFlow:  f,
		FileName:       "inline",
		Content:        content,
		MainSigner:     nil,
		Arguments:      []cadence.Value{},
		PayloadSigners: []*flowkit.Account{},
		GasLimit:       9999,
	}
}
func (t FlowTransactionBuilder) Gas(limit uint64) FlowTransactionBuilder {
	t.GasLimit = limit
	return t
}
func (t FlowTransactionBuilder) SignProposeAndPayAs(signer string) FlowTransactionBuilder {
	t.MainSigner = t.GoWithTheFlow.Account(signer)
	return t
}
func (t FlowTransactionBuilder) SignProposeAndPayAsService() FlowTransactionBuilder {
	key := fmt.Sprintf("%s-account", t.GoWithTheFlow.Network)
	account, err := t.GoWithTheFlow.State.Accounts().ByName(key)
	if err != nil {
		log.Fatal(err)
	}
	t.MainSigner = account
	return t
}
func (t FlowTransactionBuilder) RawAccountArgument(key string) FlowTransactionBuilder {
	account := flow.HexToAddress(key)
	accountArg := cadence.BytesToAddress(account.Bytes())
	return t.Argument(accountArg)
}
func (t FlowTransactionBuilder) AccountArgument(key string) FlowTransactionBuilder {
	f := t.GoWithTheFlow
	account := f.Account(key)
	return t.Argument(cadence.BytesToAddress(account.Address().Bytes()))
}
func (t FlowTransactionBuilder) StringArgument(value string) FlowTransactionBuilder {
	return t.Argument(cadence.String(value))
}
func (t FlowTransactionBuilder) BooleanArgument(value bool) FlowTransactionBuilder {
	return t.Argument(cadence.NewBool(value))
}
func (t FlowTransactionBuilder) BytesArgument(value []byte) FlowTransactionBuilder {
	return t.Argument(cadence.NewBytes(value))
}
func (t FlowTransactionBuilder) IntArgument(value int) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt(value))
}
func (t FlowTransactionBuilder) Int8Argument(value int8) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt8(value))
}
func (t FlowTransactionBuilder) Int16Argument(value int16) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt16(value))
}
func (t FlowTransactionBuilder) Int32Argument(value int32) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt32(value))
}
func (t FlowTransactionBuilder) Int64Argument(value int64) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt64(value))
}
func (t FlowTransactionBuilder) Int128Argument(value int) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt128(value))
}
func (t FlowTransactionBuilder) Int256Argument(value int) FlowTransactionBuilder {
	return t.Argument(cadence.NewInt256(value))
}
func (t FlowTransactionBuilder) UIntArgument(value uint) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt(value))
}
func (t FlowTransactionBuilder) UInt8Argument(value uint8) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt8(value))
}
func (t FlowTransactionBuilder) UInt16Argument(value uint16) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt16(value))
}
func (t FlowTransactionBuilder) UInt32Argument(value uint32) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt32(value))
}
func (t FlowTransactionBuilder) UInt64Argument(value uint64) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt64(value))
}
func (t FlowTransactionBuilder) UInt128Argument(value uint) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt128(value))
}
func (t FlowTransactionBuilder) UInt256Argument(value uint) FlowTransactionBuilder {
	return t.Argument(cadence.NewUInt256(value))
}
func (t FlowTransactionBuilder) Word8Argument(value uint8) FlowTransactionBuilder {
	return t.Argument(cadence.NewWord8(value))
}
func (t FlowTransactionBuilder) Word16Argument(value uint16) FlowTransactionBuilder {
	return t.Argument(cadence.NewWord16(value))
}
func (t FlowTransactionBuilder) Word32Argument(value uint32) FlowTransactionBuilder {
	return t.Argument(cadence.NewWord32(value))
}
func (t FlowTransactionBuilder) Word64Argument(value uint64) FlowTransactionBuilder {
	return t.Argument(cadence.NewWord64(value))
}
func (t FlowTransactionBuilder) Fix64Argument(value string) FlowTransactionBuilder {
	amount, err := cadence.NewFix64(value)
	if err != nil {
		panic(err)
	}
	return t.Argument(amount)
}
func (t FlowTransactionBuilder) DateStringAsUnixTimestamp(dateString string, timezone string) FlowTransactionBuilder {
	return t.UFix64Argument(parseTime(dateString, timezone))
}
func parseTime(timeString string, location string) string {
	loc, err := time.LoadLocation(location)
	if err != nil {
		panic(err)
	}
	time.Local = loc
	t, err := dateparse.ParseLocal(timeString)
	if err != nil {
		panic(err)
	}
	return fmt.Sprintf("%d.0", t.Unix())
}
func (t FlowTransactionBuilder) UFix64Argument(value string) FlowTransactionBuilder {
	amount, err := cadence.NewUFix64(value)
	if err != nil {
		panic(err)
	}
	return t.Argument(amount)
}
func (t FlowTransactionBuilder) Argument(value cadence.Value) FlowTransactionBuilder {
	t.Arguments = append(t.Arguments, value)
	return t
}
func (t FlowTransactionBuilder) PayloadSigner(value string) FlowTransactionBuilder {
	signer := t.GoWithTheFlow.Account(value)
	t.PayloadSigners = append(t.PayloadSigners, signer)
	return t
}
func (t FlowTransactionBuilder) RunPrintEventsFull() {
	PrintEvents(t.Run(), map[string][]string{})
}
func (t FlowTransactionBuilder) RunPrintEvents(ignoreFields map[string][]string) {
	PrintEvents(t.Run(), ignoreFields)
}
func (t FlowTransactionBuilder) Run() []flow.Event {
	events, err := t.RunE()
	if err != nil {
		t.GoWithTheFlow.Logger.Error(fmt.Sprintf("%v Error executing script: %s output %v", emoji.PileOfPoo, t.FileName, err))
		os.Exit(1)
	}
	return events
}