5551/xdrill operations

ingest/ledger_transaction.go

@@ -615,3 +615,147 @@ func (t *LedgerTransaction) NewMaxFee() (uint32, bool) {
 func (t *LedgerTransaction) Successful() bool {
 	return t.Result.Successful()
 }
+
+func (t *LedgerTransaction) GetTransactionV1Envelope() (xdr.TransactionV1Envelope, bool) {
+	switch t.Envelope.Type {
+	case xdr.EnvelopeTypeEnvelopeTypeTx:
+		switch t.Envelope.Type {
+		case 2:
+			return *t.Envelope.V1, true
+		default:
+			return xdr.TransactionV1Envelope{}, false
+		}
+	case xdr.EnvelopeTypeEnvelopeTypeTxFeeBump:
+		return t.Envelope.MustFeeBump().Tx.InnerTx.MustV1(), true
+	default:
+		return xdr.TransactionV1Envelope{}, false
+	}
+}
+
+func (t *LedgerTransaction) LedgerKeyHashesFromSorobanFootprint() []string {
+	var ledgerKeyHash []string
+
+	v1Envelope, ok := t.GetTransactionV1Envelope()
+	if !ok {
+		return ledgerKeyHash
+	}
+
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadOnly {
+		ledgerKeyBase64, err := xdr.MarshalBase64(ledgerKey)
+		if err != nil {
+			panic(err)
+		}
+		if ledgerKeyBase64 != "" {
+			ledgerKeyHash = append(ledgerKeyHash, ledgerKeyBase64)
+		}
+	}
+
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadWrite {
+		ledgerKeyBase64, err := xdr.MarshalBase64(ledgerKey)
+		if err != nil {
+			panic(err)
+		}
+		if ledgerKeyBase64 != "" {
+			ledgerKeyHash = append(ledgerKeyHash, ledgerKeyBase64)
+		}
+	}
+
+	return ledgerKeyHash
+}
+
+func (t *LedgerTransaction) ContractCodeHashFromSorobanFootprint() (string, bool) {
+	v1Envelope, ok := t.GetTransactionV1Envelope()
+	if !ok {
+		return "", false
+	}
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadOnly {
+		contractCode, ok := t.contractCodeFromContractData(ledgerKey)
+		if !ok {
+			return "", false
+		}
+		if contractCode != "" {
+			return contractCode, true
+		}
+	}
+
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadWrite {
+		contractCode, ok := t.contractCodeFromContractData(ledgerKey)
+		if !ok {
+			return "", false
+		}
+		if contractCode != "" {
+			return contractCode, true
+		}
+	}
+
+	return "", true
+}
+
+func (t *LedgerTransaction) contractCodeFromContractData(ledgerKey xdr.LedgerKey) (string, bool) {
+	contractCode, ok := ledgerKey.GetContractCode()
+	if !ok {
+		return "", false
+	}
+
+	codeHash, err := xdr.MarshalBase64(contractCode.Hash)
+	if err != nil {
+		panic(err)
+	}
+
+	return codeHash, true
+}
+
+func (t *LedgerTransaction) ContractIdFromTxEnvelope() (string, bool) {
+	v1Envelope, ok := t.GetTransactionV1Envelope()
+	if !ok {
+		return "", false
+	}
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadWrite {
+		contractId, ok := t.contractIdFromContractData(ledgerKey)
+		if !ok {
+			return "", false
+		}
+
+		if contractId != "" {
+			return contractId, true
+		}
+	}
+
+	for _, ledgerKey := range v1Envelope.Tx.Ext.SorobanData.Resources.Footprint.ReadOnly {
+		contractId, ok := t.contractIdFromContractData(ledgerKey)
+		if !ok {
+			return "", false
+		}
+
+		if contractId != "" {
+			return contractId, true
+		}
+	}
+
+	return "", true
+}
+
+func (t *LedgerTransaction) contractIdFromContractData(ledgerKey xdr.LedgerKey) (string, bool) {
+	contractData, ok := ledgerKey.GetContractData()
+	if !ok {
+		return "", false
+	}
+	contractIdHash, ok := contractData.Contract.GetContractId()
+	if !ok {
+		return "", false
+	}
+
+	var contractIdByte []byte
+	var contractId string
+	var err error
+	contractIdByte, err = contractIdHash.MarshalBinary()
+	if err != nil {
+		panic(err)
+	}
+	contractId, err = strkey.Encode(strkey.VersionByteContract, contractIdByte)
+	if err != nil {
+		panic(err)
+	}
+
+	return contractId, true
+}

ingest/processors/operation_processor/account_merge_details.go

@@ -0,0 +1,47 @@
+package operation
+
+import "fmt"
+
+type AccountMergeDetail struct {
+	Account        string `json:"account"`
+	AccountMuxed   string `json:"account_muxed"`
+	AccountMuxedID uint64 `json:"account_muxed_id,string"`
+	Into           string `json:"into"`
+	IntoMuxed      string `json:"into_muxed"`
+	IntoMuxedID    uint64 `json:"into_muxed_id,string"`
+}
+
+func (o *LedgerOperation) AccountMergeDetails() (AccountMergeDetail, error) {
+	destinationAccount, ok := o.Operation.Body.GetDestination()
+	if !ok {
+		return AccountMergeDetail{}, fmt.Errorf("could not access Destination info for this operation (index %d)", o.OperationIndex)
+	}
+
+	accountMergeDetail := AccountMergeDetail{
+		Account: o.SourceAccount(),
+		Into:    destinationAccount.Address(),
+	}
+
+	var err error
+	var accountMuxed string
+	var accountMuxedID uint64
+	accountMuxed, accountMuxedID, err = getMuxedAccountDetails(o.sourceAccountXDR())
+	if err != nil {
+		return AccountMergeDetail{}, err
+	}
+
+	accountMergeDetail.AccountMuxed = accountMuxed
+	accountMergeDetail.AccountMuxedID = accountMuxedID
+
+	var intoMuxed string
+	var intoMuxedID uint64
+	intoMuxed, intoMuxedID, err = getMuxedAccountDetails(destinationAccount)
+	if err != nil {
+		return AccountMergeDetail{}, err
+	}
+
+	accountMergeDetail.IntoMuxed = intoMuxed
+	accountMergeDetail.IntoMuxedID = intoMuxedID
+
+	return accountMergeDetail, nil
+}

ingest/processors/operation_processor/allow_trust_details.go

@@ -0,0 +1,58 @@
+package operation
+
+import (
+	"fmt"
+
+	"github.com/stellar/go/xdr"
+)
+
+type AllowTrustDetail struct {
+	AssetCode                      string `json:"asset_code"`
+	AssetIssuer                    string `json:"asset_issuer"`
+	AssetType                      string `json:"asset_type"`
+	Trustor                        string `json:"trustor"`
+	Trustee                        string `json:"trustee"`
+	TrusteeMuxed                   string `json:"trustee_muxed"`
+	TrusteeMuxedID                 uint64 `json:"trustee_muxed_id,string"`
+	Authorize                      bool   `json:"authorize"`
+	AuthorizeToMaintainLiabilities bool   `json:"authorize_to_maintain_liabilities"`
+	ClawbackEnabled                bool   `json:"clawback_enabled"`
+}
+
+func (o *LedgerOperation) AllowTrustDetails() (AllowTrustDetail, error) {
+	op, ok := o.Operation.Body.GetAllowTrustOp()
+	if !ok {
+		return AllowTrustDetail{}, fmt.Errorf("could not access AllowTrust info for this operation (index %d)", o.OperationIndex)
+	}
+
+	allowTrustDetail := AllowTrustDetail{
+		Trustor:                        op.Trustor.Address(),
+		Trustee:                        o.SourceAccount(),
+		Authorize:                      xdr.TrustLineFlags(op.Authorize).IsAuthorized(),
+		AuthorizeToMaintainLiabilities: xdr.TrustLineFlags(op.Authorize).IsAuthorizedToMaintainLiabilitiesFlag(),
+		ClawbackEnabled:                xdr.TrustLineFlags(op.Authorize).IsClawbackEnabledFlag(),
+	}
+
+	var err error
+	var assetCode, assetIssuer, assetType string
+	err = op.Asset.ToAsset(o.sourceAccountXDR().ToAccountId()).Extract(&assetType, &assetCode, &assetIssuer)
+	if err != nil {
+		return AllowTrustDetail{}, err
+	}
+
+	allowTrustDetail.AssetCode = assetCode
+	allowTrustDetail.AssetIssuer = assetIssuer
+	allowTrustDetail.AssetType = assetType
+
+	var trusteeMuxed string
+	var trusteeMuxedID uint64
+	trusteeMuxed, trusteeMuxedID, err = getMuxedAccountDetails(o.sourceAccountXDR())
+	if err != nil {
+		return AllowTrustDetail{}, err
+	}
+
+	allowTrustDetail.TrusteeMuxed = trusteeMuxed
+	allowTrustDetail.TrusteeMuxedID = trusteeMuxedID
+
+	return allowTrustDetail, nil
+}

ingest/processors/operation_processor/begin_sponsoring_future_reserve_details.go

@@ -0,0 +1,18 @@
+package operation
+
+import "fmt"
+
+type BeginSponsoringFutureReservesDetail struct {
+	SponsoredID string `json:"sponsored_id"`
+}
+
+func (o *LedgerOperation) BeginSponsoringFutureReservesDetails() (BeginSponsoringFutureReservesDetail, error) {
+	op, ok := o.Operation.Body.GetBeginSponsoringFutureReservesOp()
+	if !ok {
+		return BeginSponsoringFutureReservesDetail{}, fmt.Errorf("could not access BeginSponsoringFutureReserves info for this operation (index %d)", o.OperationIndex)
+	}
+
+	return BeginSponsoringFutureReservesDetail{
+		SponsoredID: op.SponsoredId.Address(),
+	}, nil
+}

ingest/processors/operation_processor/bump_sequence_details.go

@@ -0,0 +1,18 @@
+package operation
+
+import "fmt"
+
+type BumpSequenceDetails struct {
+	BumpTo int64 `json:"bump_to,string"`
+}
+
+func (o *LedgerOperation) BumpSequenceDetails() (BumpSequenceDetails, error) {
+	op, ok := o.Operation.Body.GetBumpSequenceOp()
+	if !ok {
+		return BumpSequenceDetails{}, fmt.Errorf("could not access BumpSequence info for this operation (index %d)", o.OperationIndex)
+	}
+
+	return BumpSequenceDetails{
+		BumpTo: int64(op.BumpTo),
+	}, nil
+}

ingest/processors/operation_processor/change_trust_details.go

@@ -0,0 +1,82 @@
+package operation
+
+import (
+	"fmt"
+
+	"github.com/stellar/go/xdr"
+)
+
+type ChangeTrustDetail struct {
+	AssetCode       string `json:"asset_code"`
+	AssetIssuer     string `json:"asset_issuer"`
+	AssetType       string `json:"asset_type"`
+	LiquidityPoolID string `json:"liquidity_pool_id"`
+	Limit           int64  `json:"limit,string"`
+	Trustee         string `json:"trustee"`
+	Trustor         string `json:"trustor"`
+	TrustorMuxed    string `json:"trustor_muxed"`
+	TrustorMuxedID  uint64 `json:"trustor_muxed_id,string"`
+}
+
+func (o *LedgerOperation) ChangeTrustDetails() (ChangeTrustDetail, error) {
+	op, ok := o.Operation.Body.GetChangeTrustOp()
+	if !ok {
+		return ChangeTrustDetail{}, fmt.Errorf("could not access GetChangeTrust info for this operation (index %d)", o.OperationIndex)
+	}
+
+	var err error
+	changeTrustDetail := ChangeTrustDetail{
+		Trustor: o.SourceAccount(),
+		Limit:   int64(op.Limit),
+	}
+
+	if op.Line.Type == xdr.AssetTypeAssetTypePoolShare {
+		changeTrustDetail.AssetType, changeTrustDetail.LiquidityPoolID, err = getLiquidityPoolAssetDetails(*op.Line.LiquidityPool)
+		if err != nil {
+			return ChangeTrustDetail{}, err
+		}
+	} else {
+		var assetCode, assetIssuer, assetType string
+		err = op.Line.ToAsset().Extract(&assetType, &assetCode, &assetIssuer)
+		if err != nil {
+			return ChangeTrustDetail{}, err
+		}
+
+		changeTrustDetail.AssetCode = assetCode
+		changeTrustDetail.AssetIssuer = assetIssuer
+		changeTrustDetail.AssetType = assetType
+		changeTrustDetail.Trustee = assetIssuer
+	}
+
+	var trustorMuxed string
+	var trustorMuxedID uint64
+	trustorMuxed, trustorMuxedID, err = getMuxedAccountDetails(o.sourceAccountXDR())
+	if err != nil {
+		return ChangeTrustDetail{}, err
+	}
+
+	changeTrustDetail.TrustorMuxed = trustorMuxed
+	changeTrustDetail.TrustorMuxedID = trustorMuxedID
+
+	return changeTrustDetail, nil
+}
+
+func getLiquidityPoolAssetDetails(lpp xdr.LiquidityPoolParameters) (string, string, error) {
+	if lpp.Type != xdr.LiquidityPoolTypeLiquidityPoolConstantProduct {
+		return "", "", fmt.Errorf("unknown liquidity pool type %d", lpp.Type)
+	}
+
+	cp := lpp.ConstantProduct
+
+	var err error
+	var poolID xdr.PoolId
+	var poolIDString string
+	poolID, err = xdr.NewPoolId(cp.AssetA, cp.AssetB, cp.Fee)
+	if err != nil {
+		return "", "", err
+	}
+
+	poolIDString = PoolIDToString(poolID)
+
+	return "liquidity_pool_shares", poolIDString, nil
+}