Merge pull request #9615 from decentraland/hotfix/2026-08-05

hotfix: buy collection store mints with credits

Author: anicalbano

Explorer/Assets/DCL/Infrastructure/Global/Dynamic/DynamicWorldContainer.cs

@@ -440,6 +440,7 @@ await MapRendererContainer
                 new CreditsManagerMetaTxRelayer(dynamicWorldDependencies.CompositeWeb3Provider, staticContainer.WebRequestsContainer.WebRequestController, bootstrapContainer.DecentralandUrlsSource, creditsChainConfig),
                 new PolygonSettlementPoller(dynamicWorldDependencies.CompositeWeb3Provider, creditsChainConfig),
                 new ManaUsdRateReader(dynamicWorldDependencies.CompositeWeb3Provider, creditsChainConfig),
+                creditsChainConfig,
                 identityCache,
                 CreditsFeatureAccess.Instance,
                 FeaturesRegistry.Instance.IsEnabled(FeatureId.CreditsWearablePurchase) && FeaturesRegistry.Instance.IsEnabled(FeatureId.UserCredits));

Explorer/Assets/DCL/MarketplaceCredits/MarketplaceCreditsAPIService/AuthorizeCreditResponse.cs

@@ -33,6 +33,14 @@ public struct AuthorizeUsdCreditBody
         public string tradeId;
     }
 
+    [Serializable]
+    public struct AuthorizeUsdMintCreditBody
+    {
+        public int usdPriceCents;
+        public string contractAddress;
+        public string itemId;
+    }
+
     [Serializable]
     public struct ReleaseUsdIntentsBody
     {

Explorer/Assets/DCL/MarketplaceCredits/MarketplaceCreditsAPIService/MarketplaceCreditsAPIClient.cs

@@ -90,15 +90,33 @@ public virtual async UniTask<CreditPacksResponse> GetCreditPacksAsync(Cancellati
                                              .CreateFromJson<CreditPacksResponse>(WRJsonParser.Unity);
         }
 
-        public virtual async UniTask<AuthorizeCreditResponse> AuthorizeUsdCreditAsync(int usdPriceCents, string tradeId, CancellationToken ct)
+        public virtual async UniTask<AuthorizeCreditResponse> AuthorizeUsdCreditAsync(int usdPriceCents, string tradeId, string contractAddress, string itemId, CancellationToken ct)
         {
             var url = $"{marketplaceCreditsBaseUrl}/credits/authorize";
-            string jsonBody = JsonUtility.ToJson(new AuthorizeUsdCreditBody { usdPriceCents = usdPriceCents, tradeId = tradeId });
+            string jsonBody = BuildAuthorizeBody(usdPriceCents, tradeId, contractAddress, itemId);
 
             return await webRequestController.SignedFetchPostAsync(url, GenericPostArguments.CreateJson(jsonBody), string.Empty, ct)
                                              .CreateFromJson<AuthorizeCreditResponse>(WRJsonParser.Unity);
         }
 
+        private static string BuildAuthorizeBody(int usdPriceCents, string? tradeId, string? contractAddress, string? itemId)
+        {
+            bool hasItem = !string.IsNullOrEmpty(contractAddress) && !string.IsNullOrEmpty(itemId);
+
+            return hasItem
+                ? JsonUtility.ToJson(new AuthorizeUsdMintCreditBody
+                {
+                    usdPriceCents = usdPriceCents,
+                    contractAddress = contractAddress,
+                    itemId = itemId,
+                })
+                : JsonUtility.ToJson(new AuthorizeUsdCreditBody
+                {
+                    usdPriceCents = usdPriceCents,
+                    tradeId = tradeId ?? string.Empty,
+                });
+        }
+
         public virtual async UniTask ReleaseUsdIntentsAsync(string[] salts, CancellationToken ct)
         {
             var url = $"{marketplaceCreditsBaseUrl}/credits/authorize/cancel";

Explorer/Assets/DCL/MarketplaceCredits/Purchase/Api/ShopListingDto.cs

@@ -9,6 +9,7 @@ namespace DCL.MarketplaceCredits.Purchase
     public class ShopListingDto
     {
         public string tradeId = null!;
+        public string? acquisition;
         public string listingType = null!;
         public string source = null!;
         public string contractAddress = null!;

Explorer/Assets/DCL/MarketplaceCredits/Purchase/Chain/CreditsChainConfig.cs

@@ -13,6 +13,17 @@ public class CreditsChainConfig
         private const string POLYGON_CREDITS_MANAGER_ADDRESS = "0x8b3a40ca1b6f5cafc99d112a4d02e897d1fd8cc5";
         private const string AMOY_CREDITS_MANAGER_ADDRESS = "0x8052a560e6e6ac86eeb7e711a4497f639b322fb3";
 
+        // CollectionStore — where a PRIMARY item with no trade is minted from (useCredits' external call target
+        // for a mint, the way the marketplace is for a trade).
+        private const string POLYGON_COLLECTION_STORE_ADDRESS = "0x214ffc0f0103735728dc66b61a22e4f163e275ae";
+        private const string AMOY_COLLECTION_STORE_ADDRESS = "0xe36abc9ec616c83caaa386541380829106149d68";
+
+        // The offchain marketplace. Not used to buy a mint — it is the contract that exposes
+        // `manaUsdAggregator()`, so it is the address the MANA/USD rate is read THROUGH. A trade already names
+        // its own marketplace; a mint has none, and a collection contract does not expose that method at all.
+        private const string POLYGON_OFFCHAIN_MARKETPLACE_ADDRESS = "0xa40b1d129b8906888720686f3a01921ddf37716f";
+        private const string AMOY_OFFCHAIN_MARKETPLACE_ADDRESS = "0x1b67d0e31eeb6b52d8eeed71d3616c2f5b33b8e7";
+
         private const string CREDITS_MANAGER_EIP712_NAME = "Decentraland Credits";
         private const string CREDITS_MANAGER_EIP712_VERSION = "1.0.0";
 
@@ -22,6 +33,10 @@ public class CreditsChainConfig
 
         public string CreditsManagerAddress { get; }
 
+        public string CollectionStoreAddress { get; }
+
+        public string OffChainMarketplaceAddress { get; }
+
         public string CreditsManagerEip712Name => CREDITS_MANAGER_EIP712_NAME;
 
         public string CreditsManagerEip712Version => CREDITS_MANAGER_EIP712_VERSION;
@@ -33,12 +48,16 @@ public CreditsChainConfig(DecentralandEnvironment environment)
                 ChainId = POLYGON_CHAIN_ID;
                 ReadonlyNetwork = POLYGON_READONLY_NETWORK;
                 CreditsManagerAddress = POLYGON_CREDITS_MANAGER_ADDRESS;
+                CollectionStoreAddress = POLYGON_COLLECTION_STORE_ADDRESS;
+                OffChainMarketplaceAddress = POLYGON_OFFCHAIN_MARKETPLACE_ADDRESS;
             }
             else
             {
                 ChainId = AMOY_CHAIN_ID;
                 ReadonlyNetwork = AMOY_READONLY_NETWORK;
                 CreditsManagerAddress = AMOY_CREDITS_MANAGER_ADDRESS;
+                CollectionStoreAddress = AMOY_COLLECTION_STORE_ADDRESS;
+                OffChainMarketplaceAddress = AMOY_OFFCHAIN_MARKETPLACE_ADDRESS;
             }
         }
     }

Explorer/Assets/DCL/MarketplaceCredits/Purchase/CreditsPurchaseService.cs

@@ -24,6 +24,7 @@ public class CreditsPurchaseService : ICreditsPurchaseService
         private readonly CreditsManagerMetaTxRelayer metaTxRelayer;
         private readonly PolygonSettlementPoller settlementPoller;
         private readonly ManaUsdRateReader manaUsdRateReader;
+        private readonly CreditsChainConfig chainConfig;
         private readonly IWeb3IdentityCache identityCache;
         private readonly CreditsFeatureAccess creditsFeatureAccess;
         private readonly bool isFeatureEnabled;
@@ -36,6 +37,7 @@ public CreditsPurchaseService(
             CreditsManagerMetaTxRelayer metaTxRelayer,
             PolygonSettlementPoller settlementPoller,
             ManaUsdRateReader manaUsdRateReader,
+            CreditsChainConfig chainConfig,
             IWeb3IdentityCache identityCache,
             CreditsFeatureAccess creditsFeatureAccess,
             bool isFeatureEnabled)
@@ -45,12 +47,13 @@ public CreditsPurchaseService(
             this.metaTxRelayer = metaTxRelayer;
             this.settlementPoller = settlementPoller;
             this.manaUsdRateReader = manaUsdRateReader;
+            this.chainConfig = chainConfig;
             this.identityCache = identityCache;
             this.creditsFeatureAccess = creditsFeatureAccess;
             this.isFeatureEnabled = isFeatureEnabled;
         }
 
-        public async UniTask<CreditsQuoteResult> QuoteAsync(string tradeId, CancellationToken ct)
+        public async UniTask<CreditsQuoteResult> QuoteAsync(ShopListingDto listing, CancellationToken ct)
         {
             if (!isFeatureEnabled || !creditsFeatureAccess.IsUserAllowed())
                 return new CreditsQuoteResult(CreditsPurchaseError.FeatureDisabled);
@@ -62,7 +65,12 @@ public async UniTask<CreditsQuoteResult> QuoteAsync(string tradeId, Cancellation
 
             SetState(CreditsPurchaseState.ResolvingListing);
 
-            try { return await QuoteInternalAsync(tradeId, identity.Address, ct); }
+            try
+            {
+                return IsStoreMint(listing)
+                    ? await QuoteStoreMintInternalAsync(listing, ct)
+                    : await QuoteInternalAsync(listing.tradeId, identity.Address, ct);
+            }
             catch (OperationCanceledException)
             {
                 return new CreditsQuoteResult(CreditsPurchaseError.Cancelled);
@@ -96,6 +104,42 @@ public async UniTask<CreditsPurchaseResult> PurchaseAsync(CreditsPurchaseQuote q
             }
         }
 
+        private static bool IsStoreMint(ShopListingDto listing) =>
+            string.Equals(listing.acquisition, "store", StringComparison.OrdinalIgnoreCase);
+
+        private async UniTask<CreditsQuoteResult> QuoteStoreMintInternalAsync(ShopListingDto listing, CancellationToken ct)
+        {
+            if (string.IsNullOrEmpty(listing.itemId))
+                return new CreditsQuoteResult(CreditsPurchaseError.ListingNotAvailable, "Mint listing has no itemId");
+
+            if (listing.available <= 0)
+                return new CreditsQuoteResult(CreditsPurchaseError.ListingNotAvailable, "Mint is sold out");
+
+            if (string.IsNullOrEmpty(listing.manaWei))
+                return new CreditsQuoteResult(CreditsPurchaseError.ListingNotAvailable, "Mint listing has no price");
+
+            ManaUsdRate rate;
+
+            try { rate = await manaUsdRateReader.ReadAsync(chainConfig.OffChainMarketplaceAddress, ct); }
+            catch (OperationCanceledException) { throw; }
+            catch (Exception e)
+            {
+                ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE,
+                    $"MANA/USD rate unavailable for mint {listing.contractAddress}-{listing.itemId}: {e.Message}");
+
+                return new CreditsQuoteResult(CreditsPurchaseError.PriceUnavailable, e.Message);
+            }
+
+            int usdCents = CreditsTradeEncoder.RoundUpToWholeCredit(CreditsTradeEncoder.ManaWeiToUsdCents(listing.manaWei!, rate), CENTS_PER_CREDIT);
+            BigInteger requiredManaWei = CreditsTradeEncoder.AmountOrZero(listing.manaWei!);
+
+            if (usdCents <= 0 || requiredManaWei <= BigInteger.Zero)
+                return new CreditsQuoteResult(CreditsPurchaseError.ListingNotAvailable, "Mint has no price");
+
+            var target = new StoreMintTarget(listing.contractAddress, listing.itemId!, listing.manaWei!);
+            return CreditsQuoteResult.Ok(CreditsPurchaseQuote.ForMint(target, usdCents, usdCents / CENTS_PER_CREDIT, requiredManaWei));
+        }
+
         private async UniTask<CreditsQuoteResult> QuoteInternalAsync(string tradeId, string buyer, CancellationToken ct)
         {
             TradeDto? trade;
@@ -161,28 +205,54 @@ private async UniTask<CreditsQuoteResult> QuoteInternalAsync(string tradeId, str
             if (usdCents <= 0)
                 return new CreditsQuoteResult(CreditsPurchaseError.ListingNotAvailable, "Trade has no price");
 
-            return CreditsQuoteResult.Ok(new CreditsPurchaseQuote(trade, usdCents, usdCents / CENTS_PER_CREDIT, requiredManaWei, isLegacyMana));
+            return CreditsQuoteResult.Ok(CreditsPurchaseQuote.ForTrade(trade, usdCents, usdCents / CENTS_PER_CREDIT, requiredManaWei, isLegacyMana));
         }
 
         private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurchaseQuote quote, string buyer, CancellationToken ct)
         {
             BigInteger requiredManaWei = quote.RequiredManaWei;
+            StoreMintTarget mint = quote.Mint;
 
-            if (!quote.IsLiveRatePrice)
+            if (quote.Kind == CreditsListingKind.StoreMint)
+            {
+                SetState(CreditsPurchaseState.ResolvingListing);
+
+                ShopListingDto? fresh;
+
+                try { fresh = await shopAPIClient.GetShopListingForItemAsync(mint.CollectionAddress, mint.ItemId, ct); }
+                catch (OperationCanceledException) { throw; }
+                catch (Exception e)
+                {
+                    ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE,
+                        $"Mint {mint.CollectionAddress}-{mint.ItemId} could not be re-read before buying: {e.Message}");
+
+                    return Fail(CreditsPurchaseError.ListingNotAvailable, message: e.Message);
+                }
+
+                if (fresh == null || !IsStoreMint(fresh) || fresh.available <= 0 || string.IsNullOrEmpty(fresh.manaWei))
+                    return Fail(CreditsPurchaseError.ListingNotAvailable, message: "The mint is no longer available");
+
+                mint = new StoreMintTarget(mint.CollectionAddress, mint.ItemId, fresh.manaWei!);
+                requiredManaWei = CreditsTradeEncoder.AmountOrZero(fresh.manaWei!);
+
+                if (requiredManaWei > quote.RequiredManaWei)
+                    return Fail(CreditsPurchaseError.PriceChanged, message: "The mint price changed");
+            }
+            else if (!quote.IsLiveRatePrice)
             {
                 SetState(CreditsPurchaseState.ResolvingListing);
 
                 ManaUsdRate rate;
 
-                try { rate = await manaUsdRateReader.ReadAsync(quote.Trade.contract, ct); }
+                try { rate = await manaUsdRateReader.ReadAsync(quote.Trade!.contract, ct); }
                 catch (OperationCanceledException) { throw; }
                 catch (Exception e)
                 {
-                    ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE, $"MANA/USD rate unavailable at purchase for trade {quote.Trade.id}: {e.Message}");
+                    ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE, $"MANA/USD rate unavailable at purchase for trade {quote.Trade!.id}: {e.Message}");
                     return Fail(CreditsPurchaseError.PriceUnavailable, message: e.Message);
                 }
 
-                requiredManaWei = CreditsTradeEncoder.UsdWeiToManaWei(quote.Trade.received[0].amount, rate);
+                requiredManaWei = CreditsTradeEncoder.UsdWeiToManaWei(quote.Trade!.received[0].amount, rate);
 
                 if (requiredManaWei <= BigInteger.Zero)
                     return Fail(CreditsPurchaseError.PriceUnavailable, message: "Trade draws no MANA");
@@ -192,7 +262,7 @@ private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurcha
 
             AuthorizeCreditResponse authorization;
 
-            try { authorization = await creditsAPIClient.AuthorizeUsdCreditAsync(quote.UsdCents, quote.Trade.id, ct); }
+            try { authorization = await creditsAPIClient.AuthorizeUsdCreditAsync(quote.UsdCents, quote.TradeId, quote.ContractAddress, quote.ItemId, ct); }
             catch (OperationCanceledException) { throw; }
             catch (UnityWebRequestException e)
             {
@@ -221,10 +291,16 @@ private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurcha
                 authorizedCap = BigInteger.Parse(authorization.maxCreditedValue)
                                 + CreditsTradeEncoder.UncreditedValue(authorization.maxCreditedValue, authorization.credit.availableAmount);
 
-                useCreditsCalldata = CreditsTradeEncoder.BuildUseCreditsCalldata(
-                    quote.Trade, buyer, authorization.credit, authorization.maxCreditedValue,
-                    DateTimeOffset.UtcNow.ToUnixTimeSeconds() + EXTERNAL_CALL_TTL_SECONDS,
-                    RandomSalt());
+                long externalCallExpiresAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + EXTERNAL_CALL_TTL_SECONDS;
+
+                useCreditsCalldata = quote.Kind == CreditsListingKind.StoreMint
+                    ? CreditsTradeEncoder.BuildStoreMintUseCreditsCalldata(
+                        chainConfig.CollectionStoreAddress, mint.CollectionAddress, mint.ItemId, mint.PriceWei,
+                        buyer, authorization.credit, authorization.maxCreditedValue,
+                        externalCallExpiresAt, RandomSalt())
+                    : CreditsTradeEncoder.BuildUseCreditsCalldata(
+                        quote.Trade!, buyer, authorization.credit, authorization.maxCreditedValue,
+                        externalCallExpiresAt, RandomSalt());
             }
             catch (Exception e)
             {
@@ -236,10 +312,10 @@ private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurcha
             if (authorizedCap < requiredManaWei)
             {
                 ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE,
-                    $"Authorized cap {authorizedCap} wei cannot cover the {requiredManaWei} wei trade {quote.Trade.id} draws");
+                    $"Authorized cap {authorizedCap} wei cannot cover the {requiredManaWei} wei {QuoteLabel(quote)} draws");
 
                 await ReleaseIntentAsync(authorization.credit.id);
-                return Fail(CreditsPurchaseError.PriceChanged, message: "The authorized credit cannot cover this trade");
+                return Fail(CreditsPurchaseError.PriceChanged, message: "The authorized credit cannot cover this purchase");
             }
 
             SetState(CreditsPurchaseState.Signing);
@@ -269,7 +345,7 @@ private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurcha
                     SetState(CreditsPurchaseState.Failed);
                     return new CreditsPurchaseResult(CreditsPurchaseError.SettlementPending, message: relay.Message);
                 case RelayOutcome.RelayerRejected:
-                    ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE, $"Relayer refused trade {quote.Trade.id}: {relay.Message}");
+                    ReportHub.LogWarning(ReportCategory.CREDITS_PURCHASE, $"Relayer refused {QuoteLabel(quote)}: {relay.Message}");
                     await ReleaseIntentAsync(authorization.credit.id);
                     return Fail(CreditsPurchaseError.RelayerUnavailable, message: relay.Message);
             }
@@ -298,6 +374,11 @@ private async UniTask<CreditsPurchaseResult> PurchaseInternalAsync(CreditsPurcha
             }
         }
 
+        private static string QuoteLabel(in CreditsPurchaseQuote quote) =>
+            quote.Kind == CreditsListingKind.StoreMint
+                ? $"mint {quote.Mint.CollectionAddress}-{quote.Mint.ItemId}"
+                : $"trade {quote.Trade!.id}";
+
         private async UniTask ReleaseIntentAsync(string creditId)
         {
             using var timeoutCts = new CancellationTokenSource(RELEASE_INTENT_TIMEOUT);