horizon/ingest: support parsing of new InvokeHostFunction op

keypair/full.go

@@ -70,6 +70,10 @@ func (kp *Full) FromAddress() *FromAddress {
 	return newFromAddressWithPublicKey(kp.address, kp.publicKey)
 }
 
+func (kp *Full) PublicKey() ed25519.PublicKey {
+	return kp.publicKey
+}
+
 func (kp *Full) Hint() (r [4]byte) {
 	copy(r[:], kp.publicKey[28:])
 	return

protocols/horizon/operations/main.go

@@ -345,6 +345,25 @@ type LiquidityPoolWithdraw struct {
 	ReservesReceived []base.AssetAmount `json:"reserves_received"`
 }
 
+// InvokeHostFunction is the json resource representing a single smart contract
+// function invocation operation, having type InvokeHostFunction.
+//
+// The model for InvokeHostFunction is intentionally simplified, Footprint
+// just contains a base64 encoded string of it's xdr serialization.
+type InvokeHostFunction struct {
+	Base
+	Parameters []HostFunctionParameter `json:"parameters"`
+	Function   string                  `json:"function"`
+	Footprint  string                  `json:"footprint"`
+}
+
+// InvokeHostFunction parameter model, intentionally simplified, Value
+// just contains a base64 encoded string of the ScVal xdr serialization.
+type HostFunctionParameter struct {
+	Value string `json:"value"`
+	Type  string `json:"type"`
+}
+
 // Operation interface contains methods implemented by the operation types
 type Operation interface {
 	GetBase() Base
@@ -573,8 +592,7 @@ func UnmarshalOperation(operationTypeID int32, dataString []byte) (ops Operation
 		}
 		ops = op
 	case xdr.OperationTypeInvokeHostFunction:
-		// TODO:
-		var op LiquidityPoolWithdraw
+		var op InvokeHostFunction
 		if err = json.Unmarshal(dataString, &op); err != nil {
 			return
 		}

services/horizon/internal/ingest/processors/effects_processor.go

@@ -223,7 +223,7 @@ func (operation *transactionOperationWrapper) effects() ([]effect, error) {
 	case xdr.OperationTypeLiquidityPoolWithdraw:
 		err = wrapper.addLiquidityPoolWithdrawEffect()
 	case xdr.OperationTypeInvokeHostFunction:
-		// TODO:
+		// TODO: https://github.com/stellar/go/issues/4585
 		return nil, nil
 	default:
 		return nil, fmt.Errorf("Unknown operation type: %s", op.Body.Type)

services/horizon/internal/ingest/processors/operations_processor.go

@@ -585,8 +585,28 @@ func (operation *transactionOperationWrapper) Details() (map[string]interface{},
 			{Asset: assetB, Amount: amount.String(receivedB)},
 		}
 	case xdr.OperationTypeInvokeHostFunction:
-		// TODO
+		op := operation.operation.Body.MustInvokeHostFunctionOp()
+		details["function"] = op.Function.String()
+		params := make([]map[string]string, 0, len(op.Parameters))
+
+		for _, param := range op.Parameters {
+			serializedParam := map[string]string{}
+			serializedParam["value"] = "n/a"
+			serializedParam["type"] = "n/a"
+
+			if name, ok := param.ArmForSwitch(int32(param.Type)); ok {
+				serializedParam["type"] = name
+				if raw, err := param.MarshalBinary(); err == nil {
+					serializedParam["value"] = base64.StdEncoding.EncodeToString(raw)
+				}
+			}
+			params = append(params, serializedParam)
+		}
 
+		details["parameters"] = params
+		if raw, err := op.Footprint.MarshalBinary(); err == nil {
+			details["footprint"] = base64.StdEncoding.EncodeToString(raw)
+		}
 	default:
 		panic(fmt.Errorf("Unknown operation type: %s", operation.OperationType()))
 	}
@@ -810,11 +830,11 @@ func (operation *transactionOperationWrapper) Participants() ([]xdr.AccountId, e
 	case xdr.OperationTypeLiquidityPoolDeposit:
 		// the only direct participant is the source_account
 	case xdr.OperationTypeLiquidityPoolWithdraw:
-	// the only direct participant is the source_account
+		// the only direct participant is the source_account
 	case xdr.OperationTypeInvokeHostFunction:
-		// TODO
+		// the only direct participant is the source_account
 	default:
-		return participants, fmt.Errorf("Unknown operation type: %s", op.Body.Type)
+		return participants, fmt.Errorf("unknown operation type: %s", op.Body.Type)
 	}
 
 	sponsor, err := operation.getSponsor()

services/horizon/internal/ingest/processors/operations_processor_test.go

@@ -4,6 +4,7 @@ package processors
 
 import (
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"testing"
 
@@ -89,6 +90,111 @@ func (s *OperationsProcessorTestSuiteLedger) mockBatchInsertAdds(txs []ingest.Le
 	return nil
 }
 
+func (s *OperationsProcessorTestSuiteLedger) TestInvokeFunctionDetails() {
+	source := xdr.MustMuxedAddress("GAUJETIZVEP2NRYLUESJ3LS66NVCEGMON4UDCBCSBEVPIID773P2W6AY")
+
+	contractParamVal1 := xdr.ScSymbol("func1")
+	contractParamVal2 := xdr.Int32(-5)
+	contractParamVal3 := xdr.Uint32(6)
+	contractParamVal4 := xdr.Uint64(3)
+	scoObjectBytes := []byte{0, 1, 2}
+	contractParamVal5 := xdr.ScObject{
+		Type: xdr.ScObjectTypeScoBytes,
+		Bin:  &scoObjectBytes,
+	}
+	contractParamVal5Addr := &contractParamVal5
+	contractParamVal6 := xdr.ScStaticScsTrue
+
+	ledgerKeyAccount := xdr.LedgerKeyAccount{
+		AccountId: source.ToAccountId(),
+	}
+
+	tx := ingest.LedgerTransaction{
+		UnsafeMeta: xdr.TransactionMeta{
+			V:  2,
+			V2: &xdr.TransactionMetaV2{},
+		},
+	}
+
+	wrapper := transactionOperationWrapper{
+		transaction: tx,
+		operation: xdr.Operation{
+			SourceAccount: &source,
+			Body: xdr.OperationBody{
+				Type: xdr.OperationTypeInvokeHostFunction,
+				InvokeHostFunctionOp: &xdr.InvokeHostFunctionOp{
+					Function: xdr.HostFunctionHostFnCall,
+					Parameters: []xdr.ScVal{
+						{
+							Type: xdr.ScValTypeScvSymbol,
+							Sym:  &contractParamVal1,
+						},
+						{
+							Type: xdr.ScValTypeScvI32,
+							I32:  &contractParamVal2,
+						},
+						{
+							Type: xdr.ScValTypeScvU32,
+							U32:  &contractParamVal3,
+						},
+						{
+							Type: xdr.ScValTypeScvBitset,
+							Bits: &contractParamVal4,
+						},
+						{
+							Type: xdr.ScValTypeScvObject,
+							Obj:  &contractParamVal5Addr,
+						},
+						{
+							Type: xdr.ScValTypeScvStatic,
+							Ic:   &contractParamVal6,
+						},
+						{
+							// invalid ScVal
+							Type: 5555,
+						},
+					},
+					Footprint: xdr.LedgerFootprint{
+						ReadOnly: []xdr.LedgerKey{
+							{
+								Type:    xdr.LedgerEntryTypeAccount,
+								Account: &ledgerKeyAccount,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	details, err := wrapper.Details()
+	s.Assert().NoError(err)
+	s.Assert().Equal(details["function"].(string), "HostFunctionHostFnCall")
+
+	raw, err := wrapper.operation.Body.InvokeHostFunctionOp.Footprint.MarshalBinary()
+	s.Assert().NoError(err)
+	s.Assert().Equal(details["footprint"].(string), base64.StdEncoding.EncodeToString(raw))
+
+	serializedParams := details["parameters"].([]map[string]string)
+	s.assertInvokeHostFunctionParameter(serializedParams, 0, "Sym", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[0])
+	s.assertInvokeHostFunctionParameter(serializedParams, 1, "I32", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[1])
+	s.assertInvokeHostFunctionParameter(serializedParams, 2, "U32", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[2])
+	s.assertInvokeHostFunctionParameter(serializedParams, 3, "Bits", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[3])
+	s.assertInvokeHostFunctionParameter(serializedParams, 4, "Obj", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[4])
+	s.assertInvokeHostFunctionParameter(serializedParams, 5, "Ic", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[5])
+	s.assertInvokeHostFunctionParameter(serializedParams, 6, "n/a", wrapper.operation.Body.InvokeHostFunctionOp.Parameters[6])
+}
+
+func (s *OperationsProcessorTestSuiteLedger) assertInvokeHostFunctionParameter(parameters []map[string]string, paramPosition int, expectedType string, expectedVal xdr.ScVal) {
+	serializedParam := parameters[paramPosition]
+	s.Assert().Equal(serializedParam["type"], expectedType)
+	if expectedSerializedXdr, err := expectedVal.MarshalBinary(); err == nil {
+		s.Assert().Equal(serializedParam["value"], base64.StdEncoding.EncodeToString(expectedSerializedXdr))
+	} else {
+		s.Assert().Equal(serializedParam["value"], "n/a")
+	}
+}
+
 func (s *OperationsProcessorTestSuiteLedger) TestAddOperationSucceeds() {
 	unmuxed := xdr.MustAddress("GA5WBPYA5Y4WAEHXWR2UKO2UO4BUGHUQ74EUPKON2QHV4WRHOIRNKKH2")
 	muxed := xdr.MuxedAccount{

services/horizon/internal/ingest/processors/stats_ledger_transaction_processor.go

@@ -49,6 +49,7 @@ type StatsLedgerTransactionProcessorResults struct {
 	OperationsSetTrustLineFlags             int64
 	OperationsLiquidityPoolDeposit          int64
 	OperationsLiquidityPoolWithdraw         int64
+	OperationsInvokeHostFunction            int64
 }
 
 func (p *StatsLedgerTransactionProcessor) ProcessTransaction(ctx context.Context, transaction ingest.LedgerTransaction) error {
@@ -116,7 +117,7 @@ func (p *StatsLedgerTransactionProcessor) ProcessTransaction(ctx context.Context
 		case xdr.OperationTypeLiquidityPoolWithdraw:
 			p.results.OperationsLiquidityPoolWithdraw++
 		case xdr.OperationTypeInvokeHostFunction:
-			// TODO
+			p.results.OperationsInvokeHostFunction++
 			return nil
 		default:
 			panic(fmt.Sprintf("Unkown operation type: %d", op.Body.Type))
@@ -164,6 +165,7 @@ func (stats *StatsLedgerTransactionProcessorResults) Map() map[string]interface{
 		"stats_operations_clawback_claimable_balance":       stats.OperationsClawbackClaimableBalance,
 		"stats_operations_liquidity_pool_deposit":           stats.OperationsLiquidityPoolDeposit,
 		"stats_operations_liquidity_pool_withdraw":          stats.OperationsLiquidityPoolWithdraw,
+		"stats_operations_invoke_host_function":             stats.OperationsInvokeHostFunction,
 	}
 }
 

services/horizon/internal/ingest/processors/transaction_operation_wrapper_test.go

@@ -2216,7 +2216,7 @@ func TestParticipantsCoversAllOperationTypes(t *testing.T) {
 	}
 	// calling Participants should error due to the unknown operation
 	_, err := operation.Participants()
-	assert.Contains(t, err.Error(), "Unknown operation type")
+	assert.Contains(t, err.Error(), "unknown operation type")
 }
 
 func TestDetailsCoversAllOperationTypes(t *testing.T) {

services/horizon/internal/integration/db_test.go

@@ -162,6 +162,19 @@ func submitPaymentOps(itest *integration.Test, tt *assert.Assertions) (submitted
 	return ops, txResp.Ledger
 }
 
+func submitInvokeHostFunction(itest *integration.Test, tt *assert.Assertions) (submittedOperations []txnbuild.Operation, lastLedger int32) {
+	ops := []txnbuild.Operation{
+		&txnbuild.InvokeHostFunction{
+			Function:   xdr.HostFunctionHostFnCall,
+			Footprint:  xdr.LedgerFootprint{},
+			Parameters: xdr.ScVec{},
+		},
+	}
+	txResp, _ := itest.SubmitOperations(itest.MasterAccount(), itest.Master(), ops...)
+
+	return ops, txResp.Ledger
+}
+
 func submitSponsorshipOps(itest *integration.Test, tt *assert.Assertions) (submittedOperations []txnbuild.Operation, lastLedger int32) {
 	keys, accounts := itest.CreateAccounts(1, "1000")
 	sponsor, sponsorPair := accounts[0], keys[0]
@@ -400,6 +413,12 @@ func initializeDBIntegrationTest(t *testing.T) (itest *integration.Test, reached
 	itest = integration.NewTest(t, integration.Config{})
 	tt := assert.New(t)
 
+	// Make sure all possible operations are covered by reingestion
+	allOpTypes := set.Set[xdr.OperationType]{}
+	for typ := range xdr.OperationTypeToStringMap {
+		allOpTypes.Add(xdr.OperationType(typ))
+	}
+
 	// submit all possible operations
 	ops, _ := submitAccountOps(itest, tt)
 	submittedOps := ops
@@ -415,16 +434,15 @@ func initializeDBIntegrationTest(t *testing.T) (itest *integration.Test, reached
 	submittedOps = append(submittedOps, ops...)
 	ops, reachedLedger = submitLiquidityPoolOps(itest, tt)
 	submittedOps = append(submittedOps, ops...)
-
-	// Make sure all possible operations are covered by reingestion
-	allOpTypes := set.Set[xdr.OperationType]{}
-	for typ := range xdr.OperationTypeToStringMap {
-		allOpTypes.Add(xdr.OperationType(typ))
+	if integration.GetCoreMaxSupportedProtocol() > 19 {
+		ops, _ = submitInvokeHostFunction(itest, tt)
+		submittedOps = append(submittedOps, ops...)
+	} else {
+		delete(allOpTypes, xdr.OperationTypeInvokeHostFunction)
 	}
+
 	// Inflation is not supported
 	delete(allOpTypes, xdr.OperationTypeInflation)
-	// TODO:
-	delete(allOpTypes, xdr.OperationTypeInvokeHostFunction)
 
 	for _, op := range submittedOps {
 		opXDR, err := op.BuildXDR()