5550/xdrill transactions

exp/xdrill/ledger/ledger.go

@@ -0,0 +1,204 @@
+package ledger
+
+import (
+	"encoding/base64"
+	"fmt"
+	"time"
+
+	"github.com/stellar/go/exp/xdrill/utils"
+	"github.com/stellar/go/xdr"
+)
+
+func Sequence(l xdr.LedgerCloseMeta) uint32 {
+	return uint32(l.LedgerHeaderHistoryEntry().Header.LedgerSeq)
+}
+
+func ID(l xdr.LedgerCloseMeta) int64 {
+	return utils.NewID(int32(l.LedgerSequence()), 0, 0).ToInt64()
+}
+
+func Hash(l xdr.LedgerCloseMeta) string {
+	return utils.HashToHexString(l.LedgerHeaderHistoryEntry().Hash)
+}
+
+func PreviousHash(l xdr.LedgerCloseMeta) string {
+	return utils.HashToHexString(l.PreviousLedgerHash())
+}
+
+func CloseTime(l xdr.LedgerCloseMeta) int64 {
+	return l.LedgerCloseTime()
+}
+
+func ClosedAt(l xdr.LedgerCloseMeta) time.Time {
+	return time.Unix(l.LedgerCloseTime(), 0).UTC()
+}
+
+func TotalCoins(l xdr.LedgerCloseMeta) int64 {
+	return int64(l.LedgerHeaderHistoryEntry().Header.TotalCoins)
+}
+
+func FeePool(l xdr.LedgerCloseMeta) int64 {
+	return int64(l.LedgerHeaderHistoryEntry().Header.FeePool)
+}
+
+func BaseFee(l xdr.LedgerCloseMeta) uint32 {
+	return uint32(l.LedgerHeaderHistoryEntry().Header.BaseFee)
+}
+
+func BaseReserve(l xdr.LedgerCloseMeta) uint32 {
+	return uint32(l.LedgerHeaderHistoryEntry().Header.BaseReserve)
+}
+
+func MaxTxSetSize(l xdr.LedgerCloseMeta) uint32 {
+	return uint32(l.LedgerHeaderHistoryEntry().Header.MaxTxSetSize)
+}
+
+func LedgerVersion(l xdr.LedgerCloseMeta) uint32 {
+	return uint32(l.LedgerHeaderHistoryEntry().Header.LedgerVersion)
+}
+
+func SorobanFeeWrite1Kb(l xdr.LedgerCloseMeta) *int64 {
+	lcmV1, ok := l.GetV1()
+	if !ok {
+		return nil
+	}
+
+	extV1, ok := lcmV1.Ext.GetV1()
+	if !ok {
+		return nil
+	}
+
+	result := int64(extV1.SorobanFeeWrite1Kb)
+
+	return &result
+}
+
+func TotalByteSizeOfBucketList(l xdr.LedgerCloseMeta) *uint64 {
+	lcmV1, ok := l.GetV1()
+	if !ok {
+		return nil
+	}
+
+	result := uint64(lcmV1.TotalByteSizeOfBucketList)
+
+	return &result
+}
+
+func NodeID(l xdr.LedgerCloseMeta) *string {
+	LedgerCloseValueSignature, ok := l.LedgerHeaderHistoryEntry().Header.ScpValue.Ext.GetLcValueSignature()
+	if !ok {
+		return nil
+
+	}
+	nodeID, ok := utils.GetAddress(LedgerCloseValueSignature.NodeId)
+	if !ok {
+		return nil
+	}
+
+	return &nodeID
+}
+
+func Signature(l xdr.LedgerCloseMeta) *string {
+	LedgerCloseValueSignature, ok := l.LedgerHeaderHistoryEntry().Header.ScpValue.Ext.GetLcValueSignature()
+	if !ok {
+		return nil
+	}
+
+	result := base64.StdEncoding.EncodeToString(LedgerCloseValueSignature.Signature)
+
+	return &result
+}
+
+// Add docstring to larger, more complicated functions
+func TransactionCounts(l xdr.LedgerCloseMeta) (successTxCount, failedTxCount int32, ok bool) {
+	var results []xdr.TransactionResultMeta
+
+	transactions := getTransactionSet(l)
+	results = l.TxProcessing()
+	txCount := len(transactions)
+	if txCount != len(results) {
+		return 0, 0, false
+	}
+
+	for i := 0; i < txCount; i++ {
+		if results[i].Result.Successful() {
+			successTxCount++
+		} else {
+			failedTxCount++
+		}
+	}
+
+	return successTxCount, failedTxCount, true
+}
+
+// Add docstring to larger, more complicated functions
+func OperationCounts(l xdr.LedgerCloseMeta) (operationCount, txSetOperationCount int32, ok bool) {
+	var results []xdr.TransactionResultMeta
+
+	transactions := getTransactionSet(l)
+	results = l.TxProcessing()
+
+	txCount := len(transactions)
+	if txCount != len(results) {
+		return 0, 0, false
+	}
+
+	for i := 0; i < txCount; i++ {
+		operations := transactions[i].Operations()
+		numberOfOps := int32(len(operations))
+		txSetOperationCount += numberOfOps
+
+		// for successful transactions, the operation count is based on the operations results slice
+		if results[i].Result.Successful() {
+			operationResults, ok := results[i].Result.OperationResults()
+			if !ok {
+				return 0, 0, false
+			}
+
+			operationCount += int32(len(operationResults))
+		}
+
+	}
+
+	return operationCount, txSetOperationCount, true
+}
+
+func getTransactionSet(l xdr.LedgerCloseMeta) (transactionProcessing []xdr.TransactionEnvelope) {
+	switch l.V {
+	case 0:
+		return l.V0.TxSet.Txs
+	case 1:
+		switch l.V1.TxSet.V {
+		case 0:
+			return getTransactionPhase(l.V1.TxSet.V1TxSet.Phases)
+		default:
+			panic(fmt.Sprintf("unsupported LedgerCloseMeta.V1.TxSet.V: %d", l.V1.TxSet.V))
+		}
+	default:
+		panic(fmt.Sprintf("unsupported LedgerCloseMeta.V: %d", l.V))
+	}
+}
+
+func getTransactionPhase(transactionPhase []xdr.TransactionPhase) (transactionEnvelope []xdr.TransactionEnvelope) {
+	transactionSlice := []xdr.TransactionEnvelope{}
+	for _, phase := range transactionPhase {
+		switch phase.V {
+		case 0:
+			components := phase.MustV0Components()
+			for _, component := range components {
+				switch component.Type {
+				case 0:
+					transactionSlice = append(transactionSlice, component.TxsMaybeDiscountedFee.Txs...)
+
+				default:
+					panic(fmt.Sprintf("unsupported TxSetComponentType: %d", component.Type))
+				}
+
+			}
+		default:
+			panic(fmt.Sprintf("unsupported TransactionPhase.V: %d", phase.V))
+		}
+	}
+
+	return transactionSlice
+}

exp/xdrill/ledger/ledger_test.go

@@ -0,0 +1,159 @@
+package ledger
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stellar/go/exp/xdrill/utils"
+	"github.com/stellar/go/xdr"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLedger(t *testing.T) {
+	ledger := ledgerTestInput()
+
+	assert.Equal(t, uint32(30578981), Sequence(ledger))
+	assert.Equal(t, int64(131335723340005376), ID(ledger))
+	assert.Equal(t, "26932dc4d84b5fabe9ae744cb43ce4c6daccf98c86a991b2a14945b1adac4d59", Hash(ledger))
+	assert.Equal(t, "f63c15d0eaf48afbd751a4c4dfade54a3448053c47c5a71d622668ae0cc2a208", PreviousHash(ledger))
+	assert.Equal(t, int64(1594584547), CloseTime(ledger))
+	assert.Equal(t, time.Time(time.Date(2020, time.July, 12, 20, 9, 7, 0, time.UTC)), ClosedAt(ledger))
+	assert.Equal(t, int64(1054439020873472865), TotalCoins(ledger))
+	assert.Equal(t, int64(18153766209161), FeePool(ledger))
+	assert.Equal(t, uint32(100), BaseFee(ledger))
+	assert.Equal(t, uint32(5000000), BaseReserve(ledger))
+	assert.Equal(t, uint32(1000), MaxTxSetSize(ledger))
+	assert.Equal(t, uint32(13), LedgerVersion(ledger))
+
+	freeWrite := SorobanFeeWrite1Kb(ledger)
+	assert.Equal(t, int64(12), *freeWrite)
+
+	bucketSize := TotalByteSizeOfBucketList(ledger)
+	assert.Equal(t, uint64(56), *bucketSize)
+
+	nodeID := NodeID(ledger)
+	assert.Equal(t, "GARAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA76O", *nodeID)
+
+	signature := Signature(ledger)
+	assert.Equal(t, "9g==", *signature)
+
+	var ok bool
+	var success int32
+	var failed int32
+	success, failed, ok = TransactionCounts(ledger)
+	assert.Equal(t, true, ok)
+	assert.Equal(t, int32(1), success)
+	assert.Equal(t, int32(1), failed)
+
+	success, failed, ok = OperationCounts(ledger)
+	assert.Equal(t, true, ok)
+	assert.Equal(t, int32(1), success)
+	assert.Equal(t, int32(13), failed)
+
+}
+
+func ledgerTestInput() (lcm xdr.LedgerCloseMeta) {
+	lcm = xdr.LedgerCloseMeta{
+		V: 1,
+		V1: &xdr.LedgerCloseMetaV1{
+			Ext: xdr.LedgerCloseMetaExt{
+				V: 1,
+				V1: &xdr.LedgerCloseMetaExtV1{
+					SorobanFeeWrite1Kb: xdr.Int64(12),
+				},
+			},
+			LedgerHeader: xdr.LedgerHeaderHistoryEntry{
+				Hash: xdr.Hash{0x26, 0x93, 0x2d, 0xc4, 0xd8, 0x4b, 0x5f, 0xab, 0xe9, 0xae, 0x74, 0x4c, 0xb4, 0x3c, 0xe4, 0xc6, 0xda, 0xcc, 0xf9, 0x8c, 0x86, 0xa9, 0x91, 0xb2, 0xa1, 0x49, 0x45, 0xb1, 0xad, 0xac, 0x4d, 0x59},
+				Header: xdr.LedgerHeader{
+					LedgerSeq:          30578981,
+					TotalCoins:         1054439020873472865,
+					FeePool:            18153766209161,
+					BaseFee:            100,
+					BaseReserve:        5000000,
+					MaxTxSetSize:       1000,
+					LedgerVersion:      13,
+					PreviousLedgerHash: xdr.Hash{0xf6, 0x3c, 0x15, 0xd0, 0xea, 0xf4, 0x8a, 0xfb, 0xd7, 0x51, 0xa4, 0xc4, 0xdf, 0xad, 0xe5, 0x4a, 0x34, 0x48, 0x5, 0x3c, 0x47, 0xc5, 0xa7, 0x1d, 0x62, 0x26, 0x68, 0xae, 0xc, 0xc2, 0xa2, 0x8},
+					ScpValue: xdr.StellarValue{
+						Ext: xdr.StellarValueExt{
+							V: 1,
+							LcValueSignature: &xdr.LedgerCloseValueSignature{
+								NodeId: xdr.NodeId{
+									Type:    0,
+									Ed25519: &xdr.Uint256{34},
+								},
+								Signature: []byte{0xf6},
+							},
+						},
+						CloseTime: 1594584547,
+					},
+				},
+			},
+			TotalByteSizeOfBucketList: xdr.Uint64(56),
+			TxSet: xdr.GeneralizedTransactionSet{
+				V: 0,
+				V1TxSet: &xdr.TransactionSetV1{
+					Phases: []xdr.TransactionPhase{
+						{
+							V: 0,
+							V0Components: &[]xdr.TxSetComponent{
+								{
+									Type: 0,
+									TxsMaybeDiscountedFee: &xdr.TxSetComponentTxsMaybeDiscountedFee{
+										Txs: []xdr.TransactionEnvelope{
+											utils.CreateSampleTx(0, 3),
+											utils.CreateSampleTx(1, 10),
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			TxProcessing: []xdr.TransactionResultMeta{
+				{
+					Result: xdr.TransactionResultPair{
+						Result: xdr.TransactionResult{
+							Result: xdr.TransactionResultResult{
+								Code: xdr.TransactionResultCodeTxSuccess,
+								Results: &[]xdr.OperationResult{
+									{
+										Code: xdr.OperationResultCodeOpInner,
+										Tr: &xdr.OperationResultTr{
+											Type: xdr.OperationTypeCreateAccount,
+											CreateAccountResult: &xdr.CreateAccountResult{
+												Code: 0,
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+				{
+					Result: xdr.TransactionResultPair{
+						Result: xdr.TransactionResult{
+							Result: xdr.TransactionResultResult{
+								Code: xdr.TransactionResultCodeTxFailed,
+								Results: &[]xdr.OperationResult{
+									{
+										Code: xdr.OperationResultCodeOpInner,
+										Tr: &xdr.OperationResultTr{
+											Type: xdr.OperationTypeCreateAccount,
+											CreateAccountResult: &xdr.CreateAccountResult{
+												Code: 0,
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	return lcm
+}