Skip to content

Commit

Permalink
Add support for simple payment
Browse files Browse the repository at this point in the history
  • Loading branch information
@karthikiyer56
karthikiyer56 committed Feb 20, 2025
1 parent f76543a commit 36946d4
Show file tree
Hide file tree
Showing 3 changed files with 113 additions and 60 deletions.
22 changes: 0 additions & 22 deletions ingest/address/address.go
View file

This file was deleted.

134 changes: 96 additions & 38 deletions ingest/processors/token_transfer/token_transfer_processor.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -71,37 +71,37 @@ 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)
return createClaimableBalanceEvents(tx, opIndex, op.Body.MustCreateClaimableBalanceOp(), opResult.Tr.MustCreateClaimableBalanceResult())
case xdr.OperationTypeClaimClaimableBalance:
return claimClaimableBalanceEvents(opIndex, op.Body.MustClaimClaimableBalanceOp(), opResult.Tr.MustClaimClaimableBalanceResult(), tx)
return claimClaimableBalanceEvents(tx, opIndex, op.Body.MustClaimClaimableBalanceOp(), opResult.Tr.MustClaimClaimableBalanceResult())
case xdr.OperationTypeClawback:
return clawbackEvents(opIndex, op.Body.MustClawbackOp(), opResult.Tr.MustClawbackResult(), tx)
return clawbackEvents(tx, opIndex, op.Body.MustClawbackOp(), opResult.Tr.MustClawbackResult())
case xdr.OperationTypeClawbackClaimableBalance:
return clawbackClaimableBalanceEvents(opIndex, op.Body.MustClawbackClaimableBalanceOp(), opResult.Tr.MustClawbackClaimableBalanceResult(), tx)
return clawbackClaimableBalanceEvents(tx, opIndex, op.Body.MustClawbackClaimableBalanceOp(), opResult.Tr.MustClawbackClaimableBalanceResult())
case xdr.OperationTypeAllowTrust:
return allowTrustEvents(opIndex, op.Body.MustAllowTrustOp(), opResult.Tr.MustAllowTrustResult(), tx)
return allowTrustEvents(tx, opIndex, op.Body.MustAllowTrustOp(), opResult.Tr.MustAllowTrustResult())
case xdr.OperationTypeSetTrustLineFlags:
return setTrustLineFlagsEvents(opIndex, op.Body.MustSetTrustLineFlagsOp(), opResult.Tr.MustSetTrustLineFlagsResult(), tx)
return setTrustLineFlagsEvents(tx, opIndex, op.Body.MustSetTrustLineFlagsOp(), opResult.Tr.MustSetTrustLineFlagsResult())
case xdr.OperationTypeLiquidityPoolDeposit:
return liquidityPoolDepositEvents(opIndex, op.Body.MustLiquidityPoolDepositOp(), opResult.Tr.MustLiquidityPoolDepositResult(), tx)
return liquidityPoolDepositEvents(tx, opIndex, op.Body.MustLiquidityPoolDepositOp(), opResult.Tr.MustLiquidityPoolDepositResult())
case xdr.OperationTypeLiquidityPoolWithdraw:
return liquidityPoolWithdrawEvents(opIndex, op.Body.MustLiquidityPoolWithdrawOp(), opResult.Tr.MustLiquidityPoolWithdrawResult(), tx)
return liquidityPoolWithdrawEvents(tx, opIndex, op.Body.MustLiquidityPoolWithdrawOp(), opResult.Tr.MustLiquidityPoolWithdrawResult())
case xdr.OperationTypeManageBuyOffer:
return manageBuyOfferEvents(opIndex, op.Body.MustManageBuyOfferOp(), opResult.Tr.MustManageBuyOfferResult(), tx)
return manageBuyOfferEvents(tx, opIndex, op.Body.MustManageBuyOfferOp(), opResult.Tr.MustManageBuyOfferResult())
case xdr.OperationTypeManageSellOffer:
return manageSellOfferEvents(opIndex, op.Body.MustManageSellOfferOp(), opResult.Tr.MustManageSellOfferResult(), tx)
return manageSellOfferEvents(tx, opIndex, op.Body.MustManageSellOfferOp(), opResult.Tr.MustManageSellOfferResult())
case xdr.OperationTypeCreatePassiveSellOffer:
return createPassiveSellOfferEvents(opIndex, op.Body.MustCreatePassiveSellOfferOp(), opResult.Tr.MustCreatePassiveSellOfferResult(), tx)
return createPassiveSellOfferEvents(tx, opIndex, op.Body.MustCreatePassiveSellOfferOp(), opResult.Tr.MustCreatePassiveSellOfferResult())
case xdr.OperationTypePathPaymentStrictSend:
return pathPaymentStrictSendEvents(opIndex, op.Body.MustPathPaymentStrictSendOp(), opResult.Tr.MustPathPaymentStrictSendResult(), tx)
return pathPaymentStrictSendEvents(tx, opIndex, op.Body.MustPathPaymentStrictSendOp(), opResult.Tr.MustPathPaymentStrictSendResult())
case xdr.OperationTypePathPaymentStrictReceive:
return pathPaymentStrictReceiveEvents(opIndex, op.Body.MustPathPaymentStrictReceiveOp(), opResult.Tr.MustPathPaymentStrictReceiveResult(), tx)
return pathPaymentStrictReceiveEvents(tx, opIndex, op.Body.MustPathPaymentStrictReceiveOp(), opResult.Tr.MustPathPaymentStrictReceiveResult())
default:
return nil, nil
}
Expand All @@ -120,91 +120,116 @@ 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()

Check failure on line 164 in ingest/processors/token_transfer/token_transfer_processor.go

View workflow job for this annotation

GitHub Actions / check (ubuntu-22.04, 1.23) 

this value of as is never used (SA4006)
// 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) {
func createClaimableBalanceEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.CreateClaimableBalanceOp, result xdr.CreateClaimableBalanceResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func claimClaimableBalanceEvents(opIndex uint32, op xdr.ClaimClaimableBalanceOp, result xdr.ClaimClaimableBalanceResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func claimClaimableBalanceEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.ClaimClaimableBalanceOp, result xdr.ClaimClaimableBalanceResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func clawbackEvents(opIndex uint32, op xdr.ClawbackOp, result xdr.ClawbackResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func clawbackEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.ClawbackOp, result xdr.ClawbackResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func clawbackClaimableBalanceEvents(opIndex uint32, op xdr.ClawbackClaimableBalanceOp, result xdr.ClawbackClaimableBalanceResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func clawbackClaimableBalanceEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.ClawbackClaimableBalanceOp, result xdr.ClawbackClaimableBalanceResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func allowTrustEvents(opIndex uint32, op xdr.AllowTrustOp, result xdr.AllowTrustResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func allowTrustEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.AllowTrustOp, result xdr.AllowTrustResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func setTrustLineFlagsEvents(opIndex uint32, op xdr.SetTrustLineFlagsOp, result xdr.SetTrustLineFlagsResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func setTrustLineFlagsEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.SetTrustLineFlagsOp, result xdr.SetTrustLineFlagsResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func liquidityPoolDepositEvents(opIndex uint32, op xdr.LiquidityPoolDepositOp, result xdr.LiquidityPoolDepositResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func liquidityPoolDepositEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.LiquidityPoolDepositOp, result xdr.LiquidityPoolDepositResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func liquidityPoolWithdrawEvents(opIndex uint32, op xdr.LiquidityPoolWithdrawOp, result xdr.LiquidityPoolWithdrawResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func liquidityPoolWithdrawEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.LiquidityPoolWithdrawOp, result xdr.LiquidityPoolWithdrawResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func manageBuyOfferEvents(opIndex uint32, op xdr.ManageBuyOfferOp, result xdr.ManageBuyOfferResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func manageBuyOfferEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.ManageBuyOfferOp, result xdr.ManageBuyOfferResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func manageSellOfferEvents(opIndex uint32, op xdr.ManageSellOfferOp, result xdr.ManageSellOfferResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func manageSellOfferEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.ManageSellOfferOp, result xdr.ManageSellOfferResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func createPassiveSellOfferEvents(opIndex uint32, op xdr.CreatePassiveSellOfferOp, result xdr.ManageSellOfferResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func createPassiveSellOfferEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.CreatePassiveSellOfferOp, result xdr.ManageSellOfferResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func pathPaymentStrictSendEvents(opIndex uint32, op xdr.PathPaymentStrictSendOp, result xdr.PathPaymentStrictSendResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func pathPaymentStrictSendEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.PathPaymentStrictSendOp, result xdr.PathPaymentStrictSendResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

func pathPaymentStrictReceiveEvents(opIndex uint32, op xdr.PathPaymentStrictReceiveOp, result xdr.PathPaymentStrictReceiveResult, tx ingest.LedgerTransaction) ([]*TokenTransferEvent, error) {
func pathPaymentStrictReceiveEvents(tx ingest.LedgerTransaction, opIndex uint32, op xdr.PathPaymentStrictReceiveOp, result xdr.PathPaymentStrictReceiveResult) ([]*TokenTransferEvent, error) {
return nil, nil
}

Expand All @@ -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 {

Check failure on line 265 in ingest/processors/token_transfer/token_transfer_processor.go

View workflow job for this annotation

GitHub Actions / check (ubuntu-22.04, 1.23) 

func addressFromLpHash is unused (U1000)
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 {

Check failure on line 272 in ingest/processors/token_transfer/token_transfer_processor.go

View workflow job for this annotation

GitHub Actions / check (ubuntu-22.04, 1.23) 

func addressFromClaimableBalanceId is unused (U1000)
return &address.Address{
AddressType: address.AddressType_ADDRESS_TYPE_LIQUIDITY_POOL,
StrKey: cb.MustV0().HexString(), //replace with strkey
}
}
17 changes: 17 additions & 0 deletions xdr/asset.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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
}

0 comments on commit 36946d4

Please sign in to comment.