Add support for simple payment

Author: karthikiyer56

ingest/address/address.go

@@ -71,11 +71,11 @@ func ProcessTokenTransferEventsFromTransaction(tx ingest.LedgerTransaction) ([]*
 func ProcessTokenTransferEventsFromOperation(opIndex uint32, op xdr.Operation, opResult xdr.OperationResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
 	switch op.Body.Type {
 	case xdr.OperationTypeCreateAccount:
-		return accountCreateEvents(opIndex, op, opResult, tx)
+		return accountCreateEvents(tx, opIndex, op)
 	case xdr.OperationTypeAccountMerge:
-		return mergeAccountEvents(opIndex, op, opResult, tx)
+		return mergeAccountEvents(tx, opIndex, op, opResult)
 	case xdr.OperationTypePayment:
-		return paymentEvents(opIndex, op.Body.MustPaymentOp(), opResult.Tr.MustPaymentResult(), tx)
+		return paymentEvents(tx, opIndex, op)
 	case xdr.OperationTypeCreateClaimableBalance:
 		return createClaimableBalanceEvents(opIndex, op.Body.MustCreateClaimableBalanceOp(), opResult.Tr.MustCreateClaimableBalanceResult(), tx)
 	case xdr.OperationTypeClaimClaimableBalance:
@@ -120,40 +120,65 @@ func generateFeeEvent(tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error
 		postBalance := change.Post.Data.MustAccount().Balance
 		accId := change.Pre.Data.MustAccount().AccountId
 		amt := amount.String(postBalance - preBalance)
-		event := NewFeeEvent(tx.Ledger.LedgerSequence(), tx.Ledger.ClosedAt(), tx.Hash.HexString(), address.AddressFromAccountId(accId), amt, asset.NewNativeAsset())
+		event := NewFeeEvent(tx.Ledger.LedgerSequence(), tx.Ledger.ClosedAt(), tx.Hash.HexString(), addressFromAccountId(accId), amt, asset.NewNativeAsset())
 		events = append(events, event)
 	}
 	return events, nil
 }
 
 // Function stubs
-func accountCreateEvents(opIndex uint32, op xdr.Operation, result xdr.OperationResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
+func accountCreateEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.Operation) ([]*TokenTransferEvent, error) {
 	srcAcc := sourceAccount(tx, op)
-
 	createAccountOp := op.Body.MustCreateAccountOp()
 	destAcc, amt := createAccountOp.Destination, amount.String(createAccountOp.StartingBalance)
 	meta := NewEventMeta(tx, &opIndex, nil)
-	event := NewTransferEvent(meta, address.AddressFromAccount(srcAcc), address.AddressFromAccountId(destAcc), amt, asset.NewNativeAsset())
+	event := NewTransferEvent(meta, addressFromAccount(srcAcc), addressFromAccountId(destAcc), amt, asset.NewNativeAsset())
 	return []*TokenTransferEvent{event}, nil // Just one event will be generated
 }
 
-func mergeAccountEvents(opIndex uint32, op xdr.Operation, result xdr.OperationResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
+func mergeAccountEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.Operation, result xdr.OperationResult) ([]*TokenTransferEvent, error) {
 	res := result.Tr.MustAccountMergeResult()
 	// If there is no transfer of XLM from source account to destination (i.e src account is empty), then no need to generate a transfer event
 	if res.SourceAccountBalance == nil {
 		return nil, nil
 	}
-
 	srcAcc := sourceAccount(tx, op)
 	destAcc := op.Body.MustDestination()
 	amt := amount.String(*res.SourceAccountBalance)
 	meta := NewEventMeta(tx, &opIndex, nil)
-	event := NewTransferEvent(meta, address.AddressFromAccount(srcAcc), address.AddressFromAccount(destAcc), amt, asset.NewNativeAsset())
+	event := NewTransferEvent(meta, addressFromAccount(srcAcc), addressFromAccount(destAcc), amt, asset.NewNativeAsset())
 	return []*TokenTransferEvent{event}, nil // Just one event will be generated
 }
 
-func paymentEvents(opIndex uint32, op xdr.PaymentOp, result xdr.PaymentResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
-	return nil, nil
+func paymentEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.Operation) ([]*TokenTransferEvent, error) {
+	paymentOp := op.Body.MustPaymentOp()
+	srcAcc := sourceAccount(tx, op)
+	destAcc := paymentOp.Destination
+	sAddress := addressFromAccount(srcAcc)
+	dAddress := addressFromAccount(destAcc)
+	amt := amount.String(paymentOp.Amount)
+	var as *asset.Asset
+	meta := NewEventMeta(tx, &opIndex, nil)
+	var event *TokenTransferEvent
+	if paymentOp.Asset.IsNative() {
+		as = asset.NewNativeAsset()
+		// If native asset, it is always a regular transfer
+		event = NewTransferEvent(meta, sAddress, dAddress, amt, asset.NewNativeAsset())
+	} else {
+		as = asset.NewIssuedAsset(paymentOp.Asset.GetCode(), paymentOp.Asset.GetIssuer())
+		assetIssuerAccountId, _ := paymentOp.Asset.GetIssuerAccountId()
+		if assetIssuerAccountId.Equals(srcAcc.ToAccountId()) {
+			// Mint event
+			event = NewMintEvent(meta, dAddress, amt, as)
+		} else if assetIssuerAccountId.Equals(destAcc.ToAccountId()) {
+			// Burn event
+			event = NewBurnEvent(meta, sAddress, amt, as)
+		} else {
+			// Regular transfer
+			event = NewTransferEvent(meta, sAddress, dAddress, amt, as)
+		}
+	}
+	return []*TokenTransferEvent{event}, nil
 }
 
 func createClaimableBalanceEvents(opIndex uint32, op xdr.CreateClaimableBalanceOp, result xdr.CreateClaimableBalanceResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
@@ -217,3 +242,36 @@ func sourceAccount(tx ingest.LedgerTransaction, op xdr.Operation) xdr.MuxedAccou
 	res := tx.Envelope.SourceAccount()
 	return res
 }
+
+func addressFromAccount(account xdr.MuxedAccount) *address.Address {
+	addr := &address.Address{}
+	switch account.Type {
+	case xdr.CryptoKeyTypeKeyTypeEd25519:
+		addr.AddressType = address.AddressType_ADDRESS_TYPE_ACCOUNT
+	case xdr.CryptoKeyTypeKeyTypeMuxedEd25519:
+		addr.AddressType = address.AddressType_ADDRESS_TYPE_MUXED_ACCOUNT
+	}
+	addr.StrKey = account.Address()
+	return addr
+}
+
+func addressFromAccountId(account xdr.AccountId) *address.Address {
+	return &address.Address{
+		AddressType: address.AddressType_ADDRESS_TYPE_ACCOUNT,
+		StrKey:      account.Address(),
+	}
+}
+
+func addressFromLpHash(lpHash xdr.PoolId) *address.Address {
+	return &address.Address{
+		AddressType: address.AddressType_ADDRESS_TYPE_LIQUIDITY_POOL,
+		StrKey:      xdr.Hash(lpHash).HexString(), // replace with strkey
+	}
+}
+
+func addressFromClaimableBalanceId(cb xdr.ClaimableBalanceId) *address.Address {
+	return &address.Address{
+		AddressType: address.AddressType_ADDRESS_TYPE_LIQUIDITY_POOL,
+		StrKey:      cb.MustV0().HexString(), //replace with strkey
+	}
+}

ingest/processors/token_transfer/token_transfer_processor.go

@@ -423,6 +423,19 @@ func (a *Asset) GetIssuer() string {
 	}
 }
 
+func (a *Asset) GetIssuerAccountId() (AccountId, error) {
+	var addr AccountId
+	switch a.Type {
+	case AssetTypeAssetTypeNative:
+		return AccountId{}, errors.New("native Asset has no issuer")
+	case AssetTypeAssetTypeCreditAlphanum4:
+		addr = (*a.AlphaNum4).Issuer
+	case AssetTypeAssetTypeCreditAlphanum12:
+		addr = (*a.AlphaNum12).Issuer
+	}
+	return addr, nil
+}
+
 func (a *Asset) LessThan(b Asset) bool {
 	if a.Type != b.Type {
 		return int32(a.Type) < int32(b.Type)
@@ -455,3 +468,7 @@ func (a Asset) ContractID(passphrase string) ([32]byte, error) {
 	}
 	return sha256.Sum256(xdrPreImageBytes), nil
 }
+
+func (a Asset) IsNative() bool {
+	return a.Type == AssetTypeAssetTypeNative
+}