handle vehicle node burn event

internal/controllers/user_devices_controller.go

@@ -2013,6 +2013,12 @@ func (udc *UserDevicesController) PostBurnDevice(c *fiber.Ctx) error {
 		return err
 	}
 
+	userDevice.R.VehicleNFT.BurnRequestID = null.StringFrom(requestID)
+
+	if _, err := userDevice.R.VehicleNFT.Update(c.Context(), udc.DBS().Writer, boil.Infer()); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "failed to associate burn request with vehicle")
+	}
+
 	logger.Info().Msgf("submitted metatransaction request %s", requestID)
 	return client.BurnVehicleSign(requestID, bvs.TokenID, sigBytes)
 }

internal/controllers/user_devices_controller_test.go

@@ -1154,4 +1154,11 @@ func (s *UserDevicesControllerTestSuite) TestPostBurn() {
 	response, err := s.app.Test(request)
 	s.Require().NoError(err)
 	s.Equal(fiber.StatusOK, response.StatusCode)
+
+	if err := vnft.Reload(context.Background(), s.pdb.DBS().Reader); err != nil {
+		s.T().Fatal(err)
+	}
+
+	s.Require().NotEmpty(vnft.BurnRequestID)
+
 }

internal/services/event_service.go

@@ -95,15 +95,15 @@ type UserDeviceIntegrationEvent struct {
 	Integration UserDeviceEventIntegration `json:"integration"`
 }
 
-type UserDeviceEventNFT struct {
-	TokenID *big.Int       `json:"tokenId"`
-	Owner   common.Address `json:"address"`
-	TxHash  common.Hash    `json:"txHash"`
-}
-
-type UserDeviceMintEvent struct {
+type UserDeviceNFTEvent struct {
 	Timestamp time.Time             `json:"timestamp"`
 	UserID    string                `json:"userId"`
 	Device    UserDeviceEventDevice `json:"device"`
-	NFT       UserDeviceEventNFT    `json:"nft"`
+	NFT       NFTEvent              `json:"nft"`
+}
+
+type NFTEvent struct {
+	TokenID *big.Int       `json:"tokenId"`
+	Owner   common.Address `json:"address"`
+	TxHash  common.Hash    `json:"txHash"`
 }

internal/services/registry/storage.go

@@ -48,6 +48,7 @@ func (p *proc) Handle(ctx context.Context, data *ceData) error {
 		models.MetaTransactionRequestWhere.ID.EQ(data.RequestID),
 		// This is really ugly. We should probably link back to the type instead of doing this.
 		qm.Load(qm.Rels(models.MetaTransactionRequestRels.MintRequestVehicleNFT, models.VehicleNFTRels.UserDevice)),
+		qm.Load(qm.Rels(models.MetaTransactionRequestRels.BurnRequestVehicleNFT, models.VehicleNFTRels.UserDevice)),
 		qm.Load(models.MetaTransactionRequestRels.ClaimMetaTransactionRequestAftermarketDevice),
 		qm.Load(models.MetaTransactionRequestRels.PairRequestAftermarketDevice),
 		qm.Load(models.MetaTransactionRequestRels.UnpairRequestAftermarketDevice),
@@ -71,6 +72,7 @@ func (p *proc) Handle(ctx context.Context, data *ceData) error {
 	}
 
 	vehicleMintedEvent := p.ABI.Events["VehicleNodeMinted"]
+	vehicleBurnedEvent := p.ABI.Events["VehicleNodeBurned"]
 	syntheticDeviceMintedEvent := p.ABI.Events["SyntheticDeviceNodeMinted"]
 	sdBurnEvent := p.ABI.Events["SyntheticDeviceNodeBurned"]
 
@@ -98,14 +100,14 @@ func (p *proc) Handle(ctx context.Context, data *ceData) error {
 						Type:    "com.dimo.zone.device.mint",
 						Subject: ud.ID,
 						Source:  "devices-api",
-						Data: services.UserDeviceMintEvent{
+						Data: services.UserDeviceNFTEvent{
 							Timestamp: time.Now(),
 							UserID:    ud.UserID,
 							Device: services.UserDeviceEventDevice{
 								ID:  ud.ID,
 								VIN: vnft.Vin,
 							},
-							NFT: services.UserDeviceEventNFT{
+							NFT: services.NFTEvent{
 								TokenID: out.TokenId,
 								Owner:   out.Owner,
 								TxHash:  common.HexToHash(data.Transaction.Hash),
@@ -138,6 +140,42 @@ func (p *proc) Handle(ctx context.Context, data *ceData) error {
 				}
 			}
 		}
+	case mtr.R.BurnRequestVehicleNFT != nil:
+		for _, l1 := range data.Transaction.Logs {
+			if l1.Topics[0] == vehicleBurnedEvent.ID {
+				out := new(contracts.RegistryVehicleNodeBurned)
+				err := p.parseLog(out, vehicleBurnedEvent, l1)
+				if err != nil {
+					return err
+				}
+
+				vnft := mtr.R.BurnRequestVehicleNFT
+				if _, err := vnft.Delete(ctx, p.DB().Writer); err != nil {
+					return err
+				}
+
+				if ud := vnft.R.UserDevice; ud != nil {
+					p.Eventer.Emit(&shared.CloudEvent[any]{ //nolint
+						Type:    "com.dimo.zone.device.burn",
+						Subject: ud.ID,
+						Source:  "devices-api",
+						Data: services.UserDeviceNFTEvent{
+							Timestamp: time.Now(),
+							UserID:    ud.UserID,
+							Device: services.UserDeviceEventDevice{
+								ID:  ud.ID,
+								VIN: vnft.Vin,
+							},
+							NFT: services.NFTEvent{
+								TokenID: out.VehicleNode,
+								TxHash:  common.HexToHash(data.Transaction.Hash),
+							},
+						},
+					})
+				}
+				logger.Info().Str("userDeviceId", mtr.R.BurnRequestVehicleNFT.UserDeviceID.String).Msg("Vehicle burned.")
+			}
+		}
 	case mtr.R.ClaimMetaTransactionRequestAftermarketDevice != nil:
 		// Handled in the contract event consumer.
 	case mtr.R.PairRequestAftermarketDevice != nil:

internal/services/registry/storage_test.go

@@ -2,6 +2,7 @@ package registry
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"math/big"
 	"testing"
@@ -101,10 +102,10 @@ func (s *StorageTestSuite) Test_SyntheticMintSetsID() {
 	s.MustInsert(&mtr)
 
 	vnft := models.VehicleNFT{
-		TransactionRequestID: mtr.ID,
-		UserDeviceID:         null.StringFrom(ud.ID),
-		TokenID:              types.NewNullDecimal(decimal.New(vehicleID, 0)),
-		OwnerAddress:         null.BytesFrom(ownerAddr.Bytes()),
+		MintRequestID: mtr.ID,
+		UserDeviceID:  null.StringFrom(ud.ID),
+		TokenID:       types.NewNullDecimal(decimal.New(vehicleID, 0)),
+		OwnerAddress:  null.BytesFrom(ownerAddr.Bytes()),
 	}
 	s.MustInsert(&vnft)
 
@@ -200,8 +201,8 @@ func (s *StorageTestSuite) TestMintVehicle() {
 	})
 
 	vnft := models.VehicleNFT{
-		TransactionRequestID: mtr.ID,
-		UserDeviceID:         null.StringFrom(ud.ID),
+		MintRequestID: mtr.ID,
+		UserDeviceID:  null.StringFrom(ud.ID),
 	}
 	s.MustInsert(&vnft)
 
@@ -234,6 +235,79 @@ func (s *StorageTestSuite) TestMintVehicle() {
 	s.Equal(ud.ID, emEv.Subject)
 }
 
+func (s *StorageTestSuite) TestBurnVehicle() {
+	logger := zerolog.Nop()
+	ctx := context.Background()
+	s.mockCtrl = gomock.NewController(s.T())
+
+	proc, err := NewProcessor(s.dbs.DBS, &logger, nil, &config.Settings{Environment: "prod"}, s.eventSvc)
+	s.Require().NoError(err)
+
+	ud := models.UserDevice{
+		ID:                 ksuid.New().String(),
+		UserID:             ksuid.New().String(),
+		DeviceDefinitionID: ksuid.New().String(),
+	}
+	s.MustInsert(&ud)
+
+	mintReq := models.MetaTransactionRequest{
+		ID:     ksuid.New().String(),
+		Status: models.MetaTransactionRequestStatusMined,
+	}
+	s.MustInsert(&mintReq)
+
+	burnReq := models.MetaTransactionRequest{
+		ID:     ksuid.New().String(),
+		Status: models.MetaTransactionRequestStatusMined,
+	}
+	s.MustInsert(&burnReq)
+
+	var emEv *shared.CloudEvent[any]
+	s.eventSvc.EXPECT().Emit(gomock.Any()).Do(func(event *shared.CloudEvent[any]) {
+		emEv = event
+	})
+
+	vnft := models.VehicleNFT{
+		MintRequestID: mintReq.ID,
+		BurnRequestID: null.StringFrom(burnReq.ID),
+		UserDeviceID:  null.StringFrom(ud.ID),
+		TokenID:       types.NewNullDecimal(decimal.New(13, 0)),
+		Vin:           "vin",
+	}
+	s.MustInsert(&vnft)
+
+	abi, err := contracts.RegistryMetaData.GetAbi()
+	if err != nil {
+		s.T().Fatal(err)
+	}
+
+	if err := proc.Handle(ctx, &ceData{
+		RequestID: burnReq.ID,
+		Type:      "Confirmed",
+		Transaction: ceTx{
+			Hash: "0x7b36384f0fcf18da09247269a4716eecbcbc475a5b2bc7aa371fc1164789508d",
+			Logs: []ceLog{
+				{
+					Topics: []common.Hash{
+						abi.Events["VehicleNodeBurned"].ID,
+						common.BigToHash(big.NewInt(13)), // token id to be burned
+						common.BigToHash(big.NewInt(1)),  // owner address
+					},
+					Data: common.FromHex(
+						"000000000000000000000000000000000000000000000000000000000000386b" +
+							"000000000000000000000000000000000000000000000000000000000000386b",
+					),
+				},
+			},
+		},
+	}); err != nil {
+		s.T().Fatal(err)
+	}
+
+	s.Require().ErrorIs(vnft.Reload(ctx, s.dbs.DBS().Writer), sql.ErrNoRows)
+	s.Equal(ud.ID, emEv.Subject)
+}
+
 func (s *StorageTestSuite) MustInsert(o boilInsertable) {
 	s.Require().NoError(o.Insert(context.TODO(), s.dbs.DBS().Writer, boil.Infer()))
 }