feat(capabilities): Merge byoc capabilities with existing capabilities and pricing (#3871)

* feat(capabilities): Add BYOC external capability and integrate pricing logic

- Introduced Capability_BYOCExternal constant to represent the new BYOC external capability.
- Updated CapabilityNameLookup to include a name for BYOC external capability.
- Enhanced GetCapabilitiesPrices method in orchestrator to append pricing for BYOC external capabilities, ensuring seamless integration with existing pricing logic.

* Add tests for BYOC external capabilities pricing

- Introduced multiple test cases for BYOC external capabilities, including validation of pricing logic and edge cases.
- Implemented tests to ensure correct pricing retrieval for both default and sender-specific scenarios.
- Added checks for handling zero and negative prices, as well as cases with nil external capabilities.

* Refactor BYOC external capability to BYOC

- Renamed Capability_BYOCExternal to Capability_BYOC for consistency.
- Updated CapabilityNameLookup and related tests to reflect the new naming.
- Adjusted orchestrator pricing logic to use the updated capability constant.

Author: eliteprox

core/capabilities.go

@@ -88,6 +88,7 @@ const (
 	Capability_ImageToText                Capability = 34
 	Capability_LiveVideoToVideo           Capability = 35
 	Capability_TextToSpeech               Capability = 36
+	Capability_BYOC                       Capability = 37
 )
 
 var CapabilityNameLookup = map[Capability]string{
@@ -129,6 +130,7 @@ var CapabilityNameLookup = map[Capability]string{
 	Capability_ImageToText:                "Image to text",
 	Capability_LiveVideoToVideo:           "Live video to video",
 	Capability_TextToSpeech:               "Text to speech",
+	Capability_BYOC:                       "byoc",
 }
 
 var CapabilityTestLookup = map[Capability]CapabilityTest{

core/orch_test.go

@@ -1667,6 +1667,140 @@ func TestAllCapsPriceInfo(t *testing.T) {
 	}
 }
 
+func TestBYOCExternalCapabilityConstant(t *testing.T) {
+	assert := assert.New(t)
+	assert.Equal(Capability(37), Capability_BYOC)
+
+	name, ok := CapabilityNameLookup[Capability_BYOC]
+	assert.True(ok, "Capability_BYOC should exist in CapabilityNameLookup")
+	assert.Equal("byoc", name)
+}
+
+func TestBYOCExternalCapsPriceInfo(t *testing.T) {
+	n, _ := NewLivepeerNode(nil, "", nil)
+	n.SetBasePrice("default", NewFixedPrice(big.NewRat(1, 1)))
+	n.Recipient = new(pm.MockRecipient)
+	orch := NewOrchestrator(n, nil)
+
+	addr1 := "0x1000000000000000000000000000000000000000"
+
+	n.ExternalCapabilities.Capabilities["my-service"] = &ExternalCapability{Name: "my-service"}
+	n.ExternalCapabilities.Capabilities["another-service"] = &ExternalCapability{Name: "another-service"}
+	n.SetPriceForExternalCapability("default", "my-service", big.NewRat(10, 1))
+	n.SetPriceForExternalCapability("default", "another-service", big.NewRat(20, 1))
+
+	// Also set a built-in cap price so we verify both coexist
+	n.SetBasePriceForCap("default", Capability_TextToImage, "default", NewFixedPrice(big.NewRat(5, 1)))
+
+	prices, err := orch.GetCapabilitiesPrices(ethcommon.HexToAddress(addr1))
+	assert.Nil(t, err)
+	assert.Len(t, prices, 3) // 1 built-in + 2 BYOC external
+
+	byocPrices := map[string]*net.PriceInfo{}
+	builtInCount := 0
+	for _, p := range prices {
+		if p.Capability == uint32(Capability_BYOC) {
+			byocPrices[p.Constraint] = p
+		} else {
+			builtInCount++
+		}
+	}
+	assert.Equal(t, 1, builtInCount)
+	assert.Len(t, byocPrices, 2)
+
+	myService := byocPrices["my-service"]
+	assert.NotNil(t, myService)
+	assert.Equal(t, int64(10), myService.PricePerUnit)
+	assert.Equal(t, int64(1), myService.PixelsPerUnit)
+	assert.Equal(t, uint32(Capability_BYOC), myService.Capability)
+	assert.Equal(t, "my-service", myService.Constraint)
+
+	anotherService := byocPrices["another-service"]
+	assert.NotNil(t, anotherService)
+	assert.Equal(t, int64(20), anotherService.PricePerUnit)
+}
+
+func TestBYOCExternalCapsSenderPricing(t *testing.T) {
+	n, _ := NewLivepeerNode(nil, "", nil)
+	n.SetBasePrice("default", NewFixedPrice(big.NewRat(1, 1)))
+	n.Recipient = new(pm.MockRecipient)
+	orch := NewOrchestrator(n, nil)
+
+	addr1 := "0x1000000000000000000000000000000000000000"
+	addr2 := "0x2000000000000000000000000000000000000000"
+	addr3 := "0x3000000000000000000000000000000000000000"
+
+	n.ExternalCapabilities.Capabilities["my-service"] = &ExternalCapability{Name: "my-service"}
+	n.SetPriceForExternalCapability("default", "my-service", big.NewRat(10, 1))
+	n.SetPriceForExternalCapability(addr1, "my-service", big.NewRat(100, 1))
+	n.SetPriceForExternalCapability(addr2, "my-service", big.NewRat(200, 1))
+
+	getBYOCPrice := func(addr string) int64 {
+		prices, err := orch.GetCapabilitiesPrices(ethcommon.HexToAddress(addr))
+		assert.Nil(t, err)
+		for _, p := range prices {
+			if p.Capability == uint32(Capability_BYOC) {
+				return p.PricePerUnit
+			}
+		}
+		t.Fatalf("no BYOC price found for %s", addr)
+		return 0
+	}
+
+	assert.Equal(t, int64(100), getBYOCPrice(addr1), "sender-specific price")
+	assert.Equal(t, int64(200), getBYOCPrice(addr2), "sender-specific price")
+	assert.Equal(t, int64(10), getBYOCPrice(addr3), "falls back to default")
+}
+
+func TestBYOCExternalCapsPriceEdgeCases(t *testing.T) {
+	addr := "0x1000000000000000000000000000000000000000"
+
+	tests := []struct {
+		name          string
+		price         *big.Rat
+		nilExtCaps    bool
+		expectPresent bool
+		expectPrice   int64
+	}{
+		{"zero price included", big.NewRat(0, 1), false, true, 0},
+		{"negative price skipped", big.NewRat(-5, 1), false, false, 0},
+		{"nil ExternalCapabilities", nil, true, false, 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			n, _ := NewLivepeerNode(nil, "", nil)
+			n.SetBasePrice("default", NewFixedPrice(big.NewRat(1, 1)))
+			n.Recipient = new(pm.MockRecipient)
+
+			if tt.nilExtCaps {
+				n.ExternalCapabilities = nil
+			} else {
+				n.ExternalCapabilities.Capabilities["svc"] = &ExternalCapability{Name: "svc"}
+				n.SetPriceForExternalCapability("default", "svc", tt.price)
+			}
+
+			orch := NewOrchestrator(n, nil)
+			prices, err := orch.GetCapabilitiesPrices(ethcommon.HexToAddress(addr))
+			assert.Nil(t, err)
+
+			var byocPrice *net.PriceInfo
+			for _, p := range prices {
+				if p.Capability == uint32(Capability_BYOC) {
+					byocPrice = p
+				}
+			}
+
+			if tt.expectPresent {
+				assert.NotNil(t, byocPrice, "BYOC price should be present")
+				assert.Equal(t, tt.expectPrice, byocPrice.PricePerUnit)
+			} else {
+				assert.Nil(t, byocPrice, "BYOC price should not be present")
+			}
+		})
+	}
+}
+
 func TestDebitFees(t *testing.T) {
 	n, _ := NewLivepeerNode(nil, "", nil)
 	n.Balances = NewAddressBalances(5 * time.Second)

core/orchestrator.go

@@ -306,6 +306,32 @@ func (orch *orchestrator) GetCapabilitiesPrices(sender ethcommon.Address) ([]*ne
 		capPrices = append(capPrices, price)
 	}
 
+	// Append BYOC external capability prices using Capability_BYOC.
+	// The registered capability name is set as the Constraint, making BYOC
+	// pricing seamless alongside built-in capabilities like LiveVideoToVideo.
+	if orch.node != nil && orch.node.ExternalCapabilities != nil {
+		for name := range orch.node.ExternalCapabilities.Capabilities {
+			price := orch.node.GetPriceForJob(ethAddr, name)
+			if price == nil {
+				price = orch.node.GetPriceForJob("default", name)
+			}
+			if price == nil || price.Num().Sign() < 0 {
+				continue
+			}
+			priceInt64, err := common.PriceToInt64(price)
+			if err != nil {
+				glog.Errorf("error converting external capability %q price to int64: %v", name, err)
+				continue
+			}
+			capPrices = append(capPrices, &net.PriceInfo{
+				PricePerUnit:  priceInt64.Num().Int64(),
+				PixelsPerUnit: priceInt64.Denom().Int64(),
+				Capability:    uint32(Capability_BYOC),
+				Constraint:    name,
+			})
+		}
+	}
+
 	return capPrices, nil
 }