fix(storage): correct epochs and cache ABI args

Author: strahe

internal/adapters/pricing.go

@@ -42,13 +42,14 @@ func perTiBGranularities(perMonth, epochsPerMonth *big.Int) storage.PricePerTiB
 
 func buildServiceParameters(p *warmstorage.ServicePrice) storage.ServiceParameters {
 	out := storage.ServiceParameters{
-		EpochDuration: chain.EpochDurationSeconds,
-		MinUploadSize: chain.MinUploadSize,
-		MaxUploadSize: chain.MaxUploadSize,
+		EpochsPerMonth: chain.EpochsPerMonth,
+		EpochsPerDay:   chain.EpochsPerDay,
+		EpochDuration:  chain.EpochDurationSeconds,
+		MinUploadSize:  chain.MinUploadSize,
+		MaxUploadSize:  chain.MaxUploadSize,
 	}
-	if p != nil && p.EpochsPerMonth != nil {
+	if p != nil && p.EpochsPerMonth != nil && p.EpochsPerMonth.Sign() > 0 && p.EpochsPerMonth.IsInt64() {
 		out.EpochsPerMonth = p.EpochsPerMonth.Int64()
-		out.EpochsPerDay = out.EpochsPerMonth / daysPerMonth
 	}
 	return out
 }

internal/adapters/pricing_test.go

@@ -8,15 +8,58 @@ import (
 	"github.com/strahe/synapse-go/warmstorage"
 )
 
-func TestBuildServiceParameters_IncludesUploadSizeBounds(t *testing.T) {
-	got := buildServiceParameters(&warmstorage.ServicePrice{
-		EpochsPerMonth: big.NewInt(2880),
-	})
+func TestBuildServiceParameters_UsesChainGeometryDefaults(t *testing.T) {
+	got := buildServiceParameters(nil)
 
 	if got.MinUploadSize != chain.MinUploadSize {
-		t.Fatalf("MinUploadSize=%d want %d", got.MinUploadSize, chain.MinUploadSize)
+		t.Errorf("MinUploadSize=%d want %d", got.MinUploadSize, chain.MinUploadSize)
 	}
 	if got.MaxUploadSize != chain.MaxUploadSize {
-		t.Fatalf("MaxUploadSize=%d want %d", got.MaxUploadSize, chain.MaxUploadSize)
+		t.Errorf("MaxUploadSize=%d want %d", got.MaxUploadSize, chain.MaxUploadSize)
+	}
+	if got.EpochsPerMonth != chain.EpochsPerMonth {
+		t.Errorf("EpochsPerMonth=%d want %d", got.EpochsPerMonth, chain.EpochsPerMonth)
+	}
+	if got.EpochsPerDay != chain.EpochsPerDay {
+		t.Errorf("EpochsPerDay=%d want %d", got.EpochsPerDay, chain.EpochsPerDay)
+	}
+}
+
+func TestBuildServiceParameters_UsesPositivePricingMonthWithoutDerivingDay(t *testing.T) {
+	epochsPerMonth := chain.EpochsPerMonth + chain.EpochsPerDay
+	got := buildServiceParameters(&warmstorage.ServicePrice{
+		EpochsPerMonth: big.NewInt(epochsPerMonth),
+	})
+
+	if got.EpochsPerMonth != epochsPerMonth {
+		t.Errorf("EpochsPerMonth=%d want %d", got.EpochsPerMonth, epochsPerMonth)
+	}
+	if got.EpochsPerDay != chain.EpochsPerDay {
+		t.Errorf("EpochsPerDay=%d want %d", got.EpochsPerDay, chain.EpochsPerDay)
+	}
+}
+
+func TestBuildServiceParameters_IgnoresInvalidPricingMonth(t *testing.T) {
+	for _, tt := range []struct {
+		name  string
+		month *big.Int
+	}{
+		{name: "nil"},
+		{name: "zero", month: new(big.Int)},
+		{name: "negative", month: big.NewInt(-1)},
+		{name: "overflow", month: new(big.Int).Lsh(big.NewInt(1), 63)},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			got := buildServiceParameters(&warmstorage.ServicePrice{
+				EpochsPerMonth: tt.month,
+			})
+
+			if got.EpochsPerMonth != chain.EpochsPerMonth {
+				t.Errorf("EpochsPerMonth=%d want %d", got.EpochsPerMonth, chain.EpochsPerMonth)
+			}
+			if got.EpochsPerDay != chain.EpochsPerDay {
+				t.Errorf("EpochsPerDay=%d want %d", got.EpochsPerDay, chain.EpochsPerDay)
+			}
+		})
 	}
 }

sessionkey/service.go

@@ -325,6 +325,16 @@ func (s *Service) GetExpirations(ctx context.Context, rootAddr, sessionKeyAddr c
 // distinguish partial-failure from transport failure via errors.Is.
 var errBatchPartial = errors.New("sessionkey.GetExpirations: partial batch failure")
 
+var uint256Args = mustABIArguments("uint256")
+
+func mustABIArguments(typeName string) abi.Arguments {
+	t, err := abi.NewType(typeName, "", nil)
+	if err != nil {
+		panic("sessionkey: failed to parse " + typeName + " ABI type: " + err.Error())
+	}
+	return abi.Arguments{{Type: t}}
+}
+
 func (s *Service) getExpirationsBatch(ctx context.Context, rootAddr, sessionKeyAddr common.Address, permissions []Permission, result Expirations) (Expirations, error) {
 	regABI, err := sessionkeyregistry.SessionKeyRegistryMetaData.GetAbi()
 	if err != nil {
@@ -349,11 +359,6 @@ func (s *Service) getExpirationsBatch(ctx context.Context, rootAddr, sessionKeyA
 		return nil, fmt.Errorf("sessionkey.GetExpirations: batch call: %w", err)
 	}
 
-	uint256Type, err := abi.NewType("uint256", "", nil)
-	if err != nil {
-		return nil, fmt.Errorf("sessionkey.GetExpirations: build uint256 type: %w", err)
-	}
-	args := abi.Arguments{{Type: uint256Type}}
 	var perCallErrs []error
 	for i, r := range results {
 		if !r.Success {
@@ -364,7 +369,7 @@ func (s *Service) getExpirationsBatch(ctx context.Context, rootAddr, sessionKeyA
 			perCallErrs = append(perCallErrs, fmt.Errorf("permission %s: empty return data", permissions[i]))
 			continue
 		}
-		vals, err := args.Unpack(r.ReturnData)
+		vals, err := uint256Args.Unpack(r.ReturnData)
 		if err != nil {
 			perCallErrs = append(perCallErrs, fmt.Errorf("permission %s: unpack: %w", permissions[i], err))
 			continue

storage/context.go

@@ -31,13 +31,24 @@ import (
 )
 
 var (
-	contextAddressType, _       = abi.NewType("address", "", nil)
-	contextUint256Type, _       = abi.NewType("uint256", "", nil)
-	contextStringArrayType, _   = abi.NewType("string[]", "", nil)
-	contextStringArray2DType, _ = abi.NewType("string[][]", "", nil)
-	contextBytesType, _         = abi.NewType("bytes", "", nil)
+	createDataSetArgs = mustABIArguments("address", "uint256", "string[]", "string[]", "bytes")
+	addPiecesArgs     = mustABIArguments("uint256", "string[][]", "string[][]", "bytes")
+	createAndAddArgs  = mustABIArguments("bytes", "bytes")
+	bytesArgs         = mustABIArguments("bytes")
 )
 
+func mustABIArguments(typeNames ...string) abi.Arguments {
+	args := make(abi.Arguments, len(typeNames))
+	for i, typeName := range typeNames {
+		t, err := abi.NewType(typeName, "", nil)
+		if err != nil {
+			panic("storage: failed to parse " + typeName + " ABI type: " + err.Error())
+		}
+		args[i] = abi.Argument{Type: t}
+	}
+	return args
+}
+
 var randReader io.Reader = rand.Reader
 
 const (
@@ -829,14 +840,7 @@ func encodeCreateDataSetExtraData(payer common.Address, clientDataSetID *big.Int
 		keys = append(keys, m.Key)
 		values = append(values, m.Value)
 	}
-	args := abi.Arguments{
-		{Type: contextAddressType},
-		{Type: contextUint256Type},
-		{Type: contextStringArrayType},
-		{Type: contextStringArrayType},
-		{Type: contextBytesType},
-	}
-	out, err := args.Pack(payer, clientDataSetID, keys, values, signature)
+	out, err := createDataSetArgs.Pack(payer, clientDataSetID, keys, values, signature)
 	if err != nil {
 		return nil, fmt.Errorf("storage: encode create dataset extraData: %w", err)
 	}
@@ -854,22 +858,15 @@ func encodeAddPiecesExtraData(nonce *big.Int, metadata [][]ityped.MetadataEntry,
 			values[i][j] = m.Value
 		}
 	}
-	args := abi.Arguments{
-		{Type: contextUint256Type},
-		{Type: contextStringArray2DType},
-		{Type: contextStringArray2DType},
-		{Type: contextBytesType},
-	}
-	out, err := args.Pack(nonce, keys, values, signature)
+	out, err := addPiecesArgs.Pack(nonce, keys, values, signature)
 	if err != nil {
 		return nil, fmt.Errorf("storage: encode add pieces extraData: %w", err)
 	}
 	return out, nil
 }
 
 func encodeCreateAndAddExtraData(createPayload, addPayload []byte) ([]byte, error) {
-	args := abi.Arguments{{Type: contextBytesType}, {Type: contextBytesType}}
-	out, err := args.Pack(createPayload, addPayload)
+	out, err := createAndAddArgs.Pack(createPayload, addPayload)
 	if err != nil {
 		return nil, fmt.Errorf("storage: encode create+add extraData: %w", err)
 	}

storage/delete.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ipfs/go-cid"
 
@@ -152,8 +151,7 @@ func (c *Context) schedulePieceDeletionByID(ctx context.Context, op string, targ
 // encodeSignatureExtraData wraps a raw 65-byte signature as
 // abi.encode(["bytes"], [sig]).
 func encodeSignatureExtraData(sig []byte) ([]byte, error) {
-	args := abi.Arguments{{Type: contextBytesType}}
-	out, err := args.Pack(sig)
+	out, err := bytesArgs.Pack(sig)
 	if err != nil {
 		return nil, fmt.Errorf("encode schedule-removal extraData: %w", err)
 	}

storage/doc.go

@@ -51,8 +51,9 @@
 // boundaries without skipping PieceCID verification. Context.Download can use
 // a CDN-backed retriever first when the context has CDN enabled, then fall back
 // to provider PDP retrieval on ordinary CDN failures. By default the HTTP
-// download client refuses to dial loopback, link-local, or private (RFC1918 /
-// ULA) addresses to guard against SSRF, and it ignores environment-variable
+// download client refuses to dial local, private, multicast, unspecified, or
+// otherwise reserved address ranges to guard against SSRF, and it ignores
+// environment-variable
 // proxies for the same reason; set [Options.AllowPrivateNetworks] when
 // connecting to trusted private infrastructure, or provide [Options.HTTPClient]
 // if you need explicit proxy control. Bound the number of bytes accepted per

storage/safe_http.go

@@ -9,7 +9,7 @@ import (
 )
 
 // newSafeHTTPClient returns an *http.Client whose transport refuses to dial
-// private/loopback/link-local/multicast/unspecified addresses. This is the
+// local, private, multicast, unspecified, or reserved addresses. This is the
 // default for Service.httpClient when neither a custom HTTPClient nor
 // AllowPrivateNetworks=true is supplied to prevent SSRF via Service.Download
 // URL-based calls. Environment-variable proxies are intentionally disabled:
@@ -36,10 +36,10 @@ func newSafeHTTPClient(timeout time.Duration, allowPrivate bool) *http.Client {
 }
 
 // safeDialContext returns a DialContext that resolves the target host and,
-// when allowPrivate is false, rejects any IP that falls into loopback,
-// link-local, RFC1918 / ULA, multicast, or unspecified ranges. Resolution is
-// performed once and the resolved IP is dialed directly, eliminating the
-// DNS-rebinding window between check and connect.
+// when allowPrivate is false, rejects any IP in local, private, multicast,
+// unspecified, or reserved ranges. Resolution is performed once and the
+// resolved IP is dialed directly, eliminating the DNS-rebinding window between
+// check and connect.
 func safeDialContext(base *net.Dialer, allowPrivate bool) func(ctx context.Context, network, addr string) (net.Conn, error) {
 	return func(ctx context.Context, network, addr string) (net.Conn, error) {
 		host, port, err := net.SplitHostPort(addr)

storage/selector.go

@@ -528,15 +528,8 @@ func detailedCandidateProviders(dataSets []*warmstorage.EnhancedDataSetInfo, sel
 }
 
 func selectMatchingDetailedDataSet(providerID types.BigInt, dataSets []*warmstorage.EnhancedDataSetInfo, requestedMetadata map[string]string) (*types.BigInt, *types.BigInt, map[string]string) {
-	matching := matchingDetailedDataSets(providerID, dataSets, requestedMetadata)
-	if len(matching) == 0 {
-		return nil, nil, nil
-	}
-	return resolvedDetailedDataSet(matching[0])
-}
-
-func matchingDetailedDataSets(providerID types.BigInt, dataSets []*warmstorage.EnhancedDataSetInfo, requestedMetadata map[string]string) []*warmstorage.EnhancedDataSetInfo {
-	matching := make([]*warmstorage.EnhancedDataSetInfo, 0, len(dataSets))
+	var best *warmstorage.EnhancedDataSetInfo
+	var bestHasPieces bool
 	for _, dataSet := range dataSets {
 		if dataSet == nil || dataSet.DataSetInfo == nil {
 			continue
@@ -550,17 +543,18 @@ func matchingDetailedDataSets(providerID types.BigInt, dataSets []*warmstorage.E
 		if !metadataMatches(dataSet.Metadata, requestedMetadata) {
 			continue
 		}
-		matching = append(matching, dataSet)
-	}
-	sort.Slice(matching, func(i, j int) bool {
-		iHasPieces := matching[i].ActivePieceCount != nil && matching[i].ActivePieceCount.Sign() > 0
-		jHasPieces := matching[j].ActivePieceCount != nil && matching[j].ActivePieceCount.Sign() > 0
-		if iHasPieces != jHasPieces {
-			return iHasPieces
+		hasPieces := dataSet.ActivePieceCount != nil && dataSet.ActivePieceCount.Sign() > 0
+		if best == nil ||
+			(hasPieces && !bestHasPieces) ||
+			(hasPieces == bestHasPieces && dataSet.DataSetID.Cmp(best.DataSetID) < 0) {
+			best = dataSet
+			bestHasPieces = hasPieces
 		}
-		return matching[i].DataSetID.Cmp(matching[j].DataSetID) < 0
-	})
-	return matching
+	}
+	if best == nil {
+		return nil, nil, nil
+	}
+	return resolvedDetailedDataSet(best)
 }
 
 func (r *ServiceResolver) dataSetAcceptsUpload(ctx context.Context, dataSetID types.BigInt) (bool, error) {

storage/selector_test.go

@@ -442,6 +442,43 @@ func TestServiceResolverResolveWritableUploadContexts_AutoSelectTrustsDetailedSn
 	}
 }
 
+func TestSelectMatchingDetailedDataSet_PrefersActiveThenLowestID(t *testing.T) {
+	providerID := testID(1)
+	dataSetID, clientDataSetID, metadata := selectMatchingDetailedDataSet(providerID, []*warmstorage.EnhancedDataSetInfo{
+		{
+			DataSetInfo:      &warmstorage.DataSetInfo{DataSetID: testID(1), ProviderID: providerID, ClientDataSetID: testID(101)},
+			IsLive:           true,
+			IsManaged:        true,
+			ActivePieceCount: new(big.Int),
+			Metadata:         map[string]string{"source": "app"},
+		},
+		{
+			DataSetInfo:      &warmstorage.DataSetInfo{DataSetID: testID(3), ProviderID: providerID, ClientDataSetID: testID(103)},
+			IsLive:           true,
+			IsManaged:        true,
+			ActivePieceCount: bigInt(2),
+			Metadata:         map[string]string{"source": "app"},
+		},
+		{
+			DataSetInfo:      &warmstorage.DataSetInfo{DataSetID: testID(2), ProviderID: providerID, ClientDataSetID: testID(102)},
+			IsLive:           true,
+			IsManaged:        true,
+			ActivePieceCount: bigInt(1),
+			Metadata:         map[string]string{"source": "app"},
+		},
+	}, map[string]string{"source": "app"})
+
+	if dataSetID == nil || !dataSetID.Equal(testID(2)) {
+		t.Fatalf("DataSetID=%v want 2", dataSetID)
+	}
+	if clientDataSetID == nil || !clientDataSetID.Equal(testID(102)) {
+		t.Fatalf("ClientDataSetID=%v want 102", clientDataSetID)
+	}
+	if metadata["source"] != "app" {
+		t.Fatalf("metadata=%v want source=app", metadata)
+	}
+}
+
 func TestServiceResolverResolveUploadContexts_AutoSelectRetriesRetryableDetailEnrichmentFailure(t *testing.T) {
 	fixture := serviceResolverFixture{
 		approvedProviderIDs: []types.BigInt{testID(1)},

storage/service.go

@@ -143,8 +143,9 @@ type Options struct {
 
 	// AllowPrivateNetworks disables the default SSRF protection applied to
 	// URL-based Service.Download calls. When false (the default), the
-	// built-in HTTP client refuses to dial loopback / link-local / RFC1918 /
-	// ULA / multicast / unspecified addresses and returns ErrPrivateNetwork.
+	// built-in HTTP client refuses to dial local, private, multicast,
+	// unspecified, or otherwise reserved address ranges and returns
+	// ErrPrivateNetwork.
 	// Set to true only when you knowingly need to download from a private
 	// network (e.g. in-cluster storage). Ignored when HTTPClient is set.
 	AllowPrivateNetworks bool