From b299b01fa4b249c2cceaa1104e4e64501e6f7166 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@google.com>
Date: Mon, 8 May 2023 14:09:53 -0400
Subject: [PATCH 01/16] First cut at doc changes

---
 FLEDGE.md                           | 47 ++++++++++++++++++++++++++---
 FLEDGE_extended_PA_reporting.md     |  2 ++
 Proposed_First_FLEDGE_OT_Details.md |  3 ++
 3 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 416dd35b8..018b6a83f 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -29,12 +29,14 @@ See [the in progress FLEDGE specification](https://wicg.github.io/turtledove/).
     - [3.3 Metadata with the Ad Bid](#33-metadata-with-the-ad-bid)
     - [3.4 Ads Composed of Multiple Pieces](#34-ads-composed-of-multiple-pieces)
     - [3.5 Filtering and Prioritizing Interest Groups](#35-filtering-and-prioritizing-interest-groups)
+    - [3.6 Currency Checking](#36-currency-checks)
   - [4. Browsers Render the Winning Ad](#4-browsers-render-the-winning-ad)
   - [5. Event-Level Reporting (for now)](#5-event-level-reporting-for-now)
     - [5.1 Seller Reporting on Render](#51-seller-reporting-on-render)
     - [5.2 Buyer Reporting on Render and Ad Events](#52-buyer-reporting-on-render-and-ad-events)
       - [5.2.1 Noised and Bucketed Signals](#521-noised-and-bucketed-signals)
-    - [5.3 Losing Bidder Reporting](#53-losing-bidder-reporting)
+    - [5.3 Reporting in Multi-Currency Auctions](#53-multi-currency-reporting)
+    - [5.4 Losing Bidder Reporting](#54-losing-bidder-reporting)
 
 
 ## Summary
@@ -239,6 +241,10 @@ const myAuctionConfig = {
                                  'https://www.another-buyer.com': 345,
                                  '*': 456,
                                  ...},
+  'perBuyerCurrencies': {'https://example.co.uk': 'GBP',
+                         'https://example.fr': 'EUR',
+                         '*': 'USD'},
+  'sellerCurrency:' : 'CAD',
   'componentAuctions': [
     {'seller': 'https://www.some-other-ssp.com',
       'decisionLogicURL': ...,
@@ -279,6 +285,8 @@ Optionally, `sellerExperimentGroupId` can be specified by the seller to support
 
 Optionally, `perBuyerPrioritySignals` is an object mapping string keys to Javascript numbers that can be used to dynamically compute interest group priorities before `perBuyerGroupLimits` are applied. See [Filtering and Prioritizing Interest Groups](#35-filtering-and-prioritizing-interest-groups) for more information.
 
+Optionally, `perBuyerCurrencies` and `sellerCurrency` are used for [currency-checking](#36-currency-checks). `sellerCurrency` is also used to [homogenize reporting in multi-currency auctions](#53-multi-currency-reporting).
+
 Optionally, `resolveToConfig` is a boolean directing the promise returned from `runAdAuction()` to resolve to a `FencedFrameConfig` if true, for use in a `<fencedframe>`, or if false to an opaque `urn:uuid` URL, for use in an `<iframe>`.  If `resolveToConfig` is not set, it defaults to false.
 If the `window.FencedFrameConfig` interface is not exposed (because e.g., the script is running in an older version of Chrome that does not yet implement `FencedFrameConfig`, then the auction will _always_ yield a URN.
 Therefore, when requesting a `FencedFrameConfig` for use in a fenced frame element, you have two options:
@@ -338,6 +346,7 @@ The function gets called once for each candidate ad in the auction.  The argumen
                        'https://cdn.com/next_ad_component_of_bid',
                        ...],
       'biddingDurationMsec': 12,
+      'bidCurrency': 'USD', /* bidCurrency returned by generateBid, or '???' if none */
       'dataVersion': 1, /* Data-Version value from the trusted scoring signals server's response */
     }
     ```
@@ -348,6 +357,7 @@ The function gets called once for each candidate ad in the auction.  The argumen
 The output of `scoreAd()` is an object with the following fields:
 * desirability: Number indicating how desirable this ad is.  Any value that is zero or negative indicates that the ad cannot win the auction.  (This could be used, for example, to eliminate any interest-group-targeted ad that would not beat a contextually-targeted candidate.) The winner of the auction is the ad object which was given the highest score.
 * allowComponentAuction: (optional) If the bid being scored is from a component auction and this value is not true, the bid is ignored. If not present, this value is considered false. This field must be present and true both when the component seller scores a bid, and when that bid is being scored by the top-level auction.
+* incomingBidInSellerCurrency: (optional) Provides a conversion of a bid in a multi-currency auction to seller's own currency. Please see [the section on this functionality](#53-multi-currency-reporting) for more details.
 
 If `scoreAd()` returns only a numeric value, it's equivalent to returning {'score': numericValue, `allowComponentAuction`: false}.
 
@@ -369,6 +379,7 @@ Seller scripts in component auctions behave a little differently.  They still ex
 * desirability: Numeric score of the bid. Must be positive or the ad will be rejected.
 * allowComponentAuction: If this field is not true, the bid will be rejected.
 * bid: (optional) Modified bid value to provide to the top-level seller script. If present, this will be passed to the top-level seller's `scoreAd()` and `reportResult()` methods instead of the original bid, if the ad wins the component auction and top-level auction, respectively.
+* bidCurrency: (optional) Annotates the currency of the modified bid provided by bid. Please see the [Currency Checking section](#36-currency-checks)
 
 Once all of a component auction's bids have been scored by the component auction's seller script, the bid with the highest score is passed to the top-level seller to score. For that bid, the top-level seller's `scoreAd()` method is passed the `ad` value from the component auction seller's `scoreAd()` method, and there is an additional `componentSeller` field in the `browserSignals`, which is the seller for the component auction. All other values are the same as if the bid had come from an interest group participating directly in the top-level auction. In the case of a tie, one of the highest scoring bids will be chosen randomly and only that bid will be passed to the top-level seller to score. The seller of a component auction may reject all bids by giving them scores <= 0. In that case, no bid from that component auction will be passed to the top-level auction.
 
@@ -504,6 +515,7 @@ generateBid(interestGroup, auctionSignals, perBuyerSignals,
   return {'ad': adObject,
           'adCost': optionalAdCost,
           'bid': bidValue,
+          'bidCurrency': 'USD',
           'render': renderURL,
           'adComponents': [adComponent1, adComponent2, ...],
           'allowComponentAuction': false,
@@ -544,6 +556,7 @@ The output of `generateBid()` contains the following fields:
 *   ad: (optional) Arbitrary metadata about the ad which this interest group wants to show. The seller uses this information in its auction and decision logic. If not present, it's treated as if the value were null.
 *   adCost: (optional) A numerical value used to pass reporting advertiser click or conversion cost from generateBid to reportWin. The precision of this number is limited to an 8-bit mantissa and 8-bit exponent, with any rounding performed stochastically.
 *   bid: A numerical bid that will enter the auction.  The seller must be in a position to compare bids from different buyers, therefore bids must be in some seller-chosen unit (e.g. "USD per thousand").  If the bid is zero or negative, then this interest group will not participate in the seller's auction at all.  With this mechanism, the buyer can implement any advertiser rules for where their ads may or may not appear.
+*   bidCurrency: (optional) The currency for the bid, used for [currency-checking](#36-currency-checks).
 *   render: A URL which will be rendered to display the creative if this bid wins the auction.
 *   adComponents: (optional) A list of up to 20 adComponent strings from the InterestGroup's adComponents field. Each value must match an adComponent renderURL exactly. This field must not be present if the InterestGroup has no adComponent field. It is valid for this field not to be present even when adComponents is present. (See ["Ads Composed of Multiple Pieces"](#34-ads-composed-of-multiple-pieces) below.)
 *   allowComponentAuction: If this buyer is taking part of a component auction, this value must be present and true, or the bid is ignored. This value is ignored (and may be absent) if the buyer is part of a top-level auction.
@@ -633,6 +646,16 @@ The `BidFor240Minutes` interest group will have a positive priority if it was jo
 
 The `FilterOnDataFromServer` interest group will result in fetching `https://buyer1.com/bidder_signals?publisher=<...>&interest_groups=FilterOnDataFromServer,<...>`, and then if that result has a `perInterestGroupData.FilterOnDataFromServer.priorityVector` object, then that is used just like the `priorityVector` field from the other two examples, except that it's only used for filtering, not to set the priority (unless the group has a true `enableBiddingSignalsPrioritization` field).  A [user defined function](https://github.com/privacysandbox/fledge-docs/blob/main/key_value_service_trust_model.md#support-for-user-defined-functions-udfs) could be used on the FLEDGE Key-Value server to calculate that `priorityVector` value, and hence to decide if `FilterOnDataFromServer`'s `generateBid()` method is invoked or if it's filtered out.
 
+### 3.6 Currency Checking
+
+If participants in the auction need to deal with multiple currencies, they can optionally take advantage of automated currency checking. All of it operates on currency tags, which are required to contain 3 upper-case ASCII letters.
+
+If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for it is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as '???'.
+
+Checking inside `scoreAd` happens only inside component auctions.  If the auction modifies the bid, the modified version will be checked; if not, the passed-through bid from the original buyer will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
+
+`sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-multi-currency-reporting) for more details.
+
 ### 4. Browsers Render the Winning Ad
 
 The winning ad will be rendered in a [Fenced Frame](https://github.com/shivanigithub/fenced-frame): a mechanism under development for rendering a document in an embedded context which is unable to communicate with the surrounding page.  This communication blockage is necessary to meet the privacy goal that sites cannot learn about their visitors' ad interests.  (Note that the microtargeting prevention threshold alone is not enough to address this threat: the threshold prevents ads which could identify a single person, but it allows ads which identify a group of people that share a single interest.)
@@ -683,14 +706,17 @@ The arguments to this function are:
       'componentSeller': 'https://www.some-other-ssp.com',
       'interestGroupOwner': 'https://www.example-dsp.com/',
       'renderURL': 'https://cdn.com/url-of-winning-creative.wbn',
-      'bid:' bidValue,
+      'bid': bidValue,
+      'bidCurrency': ...,
       'desirability': desirabilityScoreForWinningAd,
       'topLevelSellerSignals': outputOfTopLevelSellersReportResult,
       'dataVersion': versionFromKeyValueResponse,
       'modifiedBid': modifiedBidValue,
-      'highestScoringOtherBid': highestScoringOtherBidValue
+      'highestScoringOtherBid': highestScoringOtherBidValue,
+      'highestScoringOtherBidCurrency': ...
     }
     ```
+    * `bidCurrency` and `highestScoringOtherBidCurrency` provide (highly redacted) information on what currency the corresponding numbers are in. Please refer to the section on [Reporting in Multi-Currency Auctions](#53-multi-currency-reporting) for more details.
 *   directFromSellerSignals is an object that may contain the following fields:
     *   sellerSignals: Like auctionConfig.sellerSignals, but passed via the [directFromSellerSignals](#25-additional-trusted-signals-directfromsellersignals) mechanism. These are the signals whose subresource URL ends in `?sellerSignals`.
     *   auctionSignals: Like auctionConfig.auctionSignals, but passed via the [directFromSellerSignals](#25-additional-trusted-signals-directfromsellersignals) mechanism. These are the signals whose subresource URL ends in `?auctionSignals`.
@@ -747,7 +773,20 @@ When `joinCount` is passed to `generateBid()`, no noising or bucketing is applie
 
 These signals were requested in [issue 435](https://github.com/WICG/turtledove/issues/435). The signals are intented to ship in Chrome M114, they will no longer be available for event level reporting when event level reporting is retired.
 
-#### 5.3 Losing Bidder Reporting
+#### 5.3 Reporting in Multi-Currency Auctions
+
+In auctions that involve multiple currencies, there may be values with different units floating around, which makes aggregated information incomprehensible, and event-level information hard to process, potentially requiring participants to interpret currencies of jurisdictions they do no business in.
+
+To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
+
+If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to '???', with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`.
+
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, the value used for reporting and private aggregation is zero.  In this mode, all APIs like event reporting, debug event-level loss reporting, and private aggregation will see the converted values, with the `sellerCurrency` as the appropriate currency tag, except the invocation of `reportWin()` (but not private aggregation triggered off `reportWin()` will once again see its own value and currency for `bid` and `bidCurrency` (but not `highestScoringOtherBid` and `highestScoringOtherBidCurrency`).
+
+Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
+
+
+#### 5.4 Losing Bidder Reporting
 
 We also need to provide a mechanism for the _losing_ bidders in the auction to learn aggregate outcomes.  Certainly they should be able to count the number of times they bid, and losing ads should also be able to learn (in aggregate) some seller-provided information about e.g. the auction clearing price.  Likewise, a reporting mechanism should be available to buyers who attempted to bid with a creative that had not yet reached the k-anonymity threshold.
 
diff --git a/FLEDGE_extended_PA_reporting.md b/FLEDGE_extended_PA_reporting.md
index 4fbd6c7e1..204be2e43 100644
--- a/FLEDGE_extended_PA_reporting.md
+++ b/FLEDGE_extended_PA_reporting.md
@@ -204,6 +204,8 @@ Where `signalBucket` and `signalValue` is a dictionary which consists of:
     * 6: indicates seller rejected bid because “Creative Filtered - Language Exclusions”
     * 7: indicates seller rejected bid because “Creative Filtered - Category Exclusions”
     * 8: indicates seller rejected bid because "Creative Filtered - Did Not Meet The K-anonymity Threshold"
+    * 9: indicates bid produced by generateBid() was rejected because it failed a currency check
+    * 10: indicates bid passed through or altered by scoreAd() was rejected because it failed a currency check
     * Perhaps other values indicating:
       * generateBid() hitting timeout
       * The auction was aborted (i.e. calling endAdAuction())
diff --git a/Proposed_First_FLEDGE_OT_Details.md b/Proposed_First_FLEDGE_OT_Details.md
index 4089669f9..92a6424c8 100644
--- a/Proposed_First_FLEDGE_OT_Details.md
+++ b/Proposed_First_FLEDGE_OT_Details.md
@@ -61,10 +61,13 @@ As the FLEDGE explainer talks about, the FOT#1 will include event-level reportin
 The FOT#1 will include event-level reporting for both winning and losing bids. Implementations of the `generateBid()` and `scoreAd()` worklets, provided by the buyers and sellers respectively in the auction, may call a `forDebuggingOnly.reportAdAuctionLoss()` API which takes a single string argument representing a URL. The text placeholders below will be replaced with the corresponding value from the auction when found in the reporting URL's query parameters (note that due to http://crbug.com/1338233, prior to Chrome version 107.0.5286.0, the replacements only took place in the path of the URL)
 
 *   “${winningBid}” - The value of the winning bid.  In component auctions, this value comes from the component auction and not the top-level auction.
+*   “${winningBidCurrency}” - The currency `winningBid` is in. This is '???' if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
 *   “${madeWinningBid}” - A boolean value representing whether the owner of this interest group made the winning bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${highestScoringOtherBid}” - The value of the bid  that was scored as second highest by the seller’s scoreAd script. Note that this may not be the second highest bid value, since scores and bids may be independent.  In component auctions, this value comes from the component auction and not the top-level auction.
+*   “${highestScoringOtherBidCurrency}” - The currency `highestScoringOtherBid` is in. This is '???' if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
 *   “${madeHighestScoringOtherBid}” - A boolean value representing whether the owner of this interest group made the ${highestScoringOtherBid} bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${topLevelWinningBid}” - The value of the bid that won the top-level auction.  This value is only reported in component auctions.
+*   “${topLevelWinningBidCurrency}” - The currency `topLevelWinningBid` is in. This is '???' if it's in whatever currency the component auction made the bid in, or is a currency tag if it's in top-level auction's seller currency.
 *   “${topLevelMadeWinningBid}” - A boolean value representing whether the owner of this interest group made the bid that won the top-level auction, either via this interest group, or another interest group with the same owner. This value is only reported in component auctions.
 
 If the bid being generated or scored loses the auction, the URL will be fetched. These worklets may also call a `forDebuggingOnly.reportAdAuctionWin()` API which operates similarly to `forDebuggingOnly.reportAdAuctionLoss()` API but only fetches the URL after a winning bid or score.

From e937dceb0cb25cb1be2fafb0ec89b9add057e49c Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@google.com>
Date: Mon, 8 May 2023 14:16:01 -0400
Subject: [PATCH 02/16] formatting/link fixes

---
 FLEDGE.md                           | 20 ++++++++++----------
 Proposed_First_FLEDGE_OT_Details.md |  6 +++---
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 018b6a83f..4b5af2725 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -29,13 +29,13 @@ See [the in progress FLEDGE specification](https://wicg.github.io/turtledove/).
     - [3.3 Metadata with the Ad Bid](#33-metadata-with-the-ad-bid)
     - [3.4 Ads Composed of Multiple Pieces](#34-ads-composed-of-multiple-pieces)
     - [3.5 Filtering and Prioritizing Interest Groups](#35-filtering-and-prioritizing-interest-groups)
-    - [3.6 Currency Checking](#36-currency-checks)
+    - [3.6 Currency Checking](#36-currency-checking)
   - [4. Browsers Render the Winning Ad](#4-browsers-render-the-winning-ad)
   - [5. Event-Level Reporting (for now)](#5-event-level-reporting-for-now)
     - [5.1 Seller Reporting on Render](#51-seller-reporting-on-render)
     - [5.2 Buyer Reporting on Render and Ad Events](#52-buyer-reporting-on-render-and-ad-events)
       - [5.2.1 Noised and Bucketed Signals](#521-noised-and-bucketed-signals)
-    - [5.3 Reporting in Multi-Currency Auctions](#53-multi-currency-reporting)
+    - [5.3 Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions)
     - [5.4 Losing Bidder Reporting](#54-losing-bidder-reporting)
 
 
@@ -285,7 +285,7 @@ Optionally, `sellerExperimentGroupId` can be specified by the seller to support
 
 Optionally, `perBuyerPrioritySignals` is an object mapping string keys to Javascript numbers that can be used to dynamically compute interest group priorities before `perBuyerGroupLimits` are applied. See [Filtering and Prioritizing Interest Groups](#35-filtering-and-prioritizing-interest-groups) for more information.
 
-Optionally, `perBuyerCurrencies` and `sellerCurrency` are used for [currency-checking](#36-currency-checks). `sellerCurrency` is also used to [homogenize reporting in multi-currency auctions](#53-multi-currency-reporting).
+Optionally, `perBuyerCurrencies` and `sellerCurrency` are used for [currency-checking](#36-currency-checking). `sellerCurrency` is also used to [homogenize reporting in multi-currency auctions](#53-reporting-in-multi-currency-auctions).
 
 Optionally, `resolveToConfig` is a boolean directing the promise returned from `runAdAuction()` to resolve to a `FencedFrameConfig` if true, for use in a `<fencedframe>`, or if false to an opaque `urn:uuid` URL, for use in an `<iframe>`.  If `resolveToConfig` is not set, it defaults to false.
 If the `window.FencedFrameConfig` interface is not exposed (because e.g., the script is running in an older version of Chrome that does not yet implement `FencedFrameConfig`, then the auction will _always_ yield a URN.
@@ -357,7 +357,7 @@ The function gets called once for each candidate ad in the auction.  The argumen
 The output of `scoreAd()` is an object with the following fields:
 * desirability: Number indicating how desirable this ad is.  Any value that is zero or negative indicates that the ad cannot win the auction.  (This could be used, for example, to eliminate any interest-group-targeted ad that would not beat a contextually-targeted candidate.) The winner of the auction is the ad object which was given the highest score.
 * allowComponentAuction: (optional) If the bid being scored is from a component auction and this value is not true, the bid is ignored. If not present, this value is considered false. This field must be present and true both when the component seller scores a bid, and when that bid is being scored by the top-level auction.
-* incomingBidInSellerCurrency: (optional) Provides a conversion of a bid in a multi-currency auction to seller's own currency. Please see [the section on this functionality](#53-multi-currency-reporting) for more details.
+* incomingBidInSellerCurrency: (optional) Provides a conversion of a bid in a multi-currency auction to seller's own currency. Please see [the section on this functionality](#53-reporting-in-multi-currency-auctions) for more details.
 
 If `scoreAd()` returns only a numeric value, it's equivalent to returning {'score': numericValue, `allowComponentAuction`: false}.
 
@@ -379,7 +379,7 @@ Seller scripts in component auctions behave a little differently.  They still ex
 * desirability: Numeric score of the bid. Must be positive or the ad will be rejected.
 * allowComponentAuction: If this field is not true, the bid will be rejected.
 * bid: (optional) Modified bid value to provide to the top-level seller script. If present, this will be passed to the top-level seller's `scoreAd()` and `reportResult()` methods instead of the original bid, if the ad wins the component auction and top-level auction, respectively.
-* bidCurrency: (optional) Annotates the currency of the modified bid provided by bid. Please see the [Currency Checking section](#36-currency-checks)
+* bidCurrency: (optional) Annotates the currency of the modified bid provided by bid. Please see the [Currency Checking section](#36-currency-checking)
 
 Once all of a component auction's bids have been scored by the component auction's seller script, the bid with the highest score is passed to the top-level seller to score. For that bid, the top-level seller's `scoreAd()` method is passed the `ad` value from the component auction seller's `scoreAd()` method, and there is an additional `componentSeller` field in the `browserSignals`, which is the seller for the component auction. All other values are the same as if the bid had come from an interest group participating directly in the top-level auction. In the case of a tie, one of the highest scoring bids will be chosen randomly and only that bid will be passed to the top-level seller to score. The seller of a component auction may reject all bids by giving them scores <= 0. In that case, no bid from that component auction will be passed to the top-level auction.
 
@@ -556,7 +556,7 @@ The output of `generateBid()` contains the following fields:
 *   ad: (optional) Arbitrary metadata about the ad which this interest group wants to show. The seller uses this information in its auction and decision logic. If not present, it's treated as if the value were null.
 *   adCost: (optional) A numerical value used to pass reporting advertiser click or conversion cost from generateBid to reportWin. The precision of this number is limited to an 8-bit mantissa and 8-bit exponent, with any rounding performed stochastically.
 *   bid: A numerical bid that will enter the auction.  The seller must be in a position to compare bids from different buyers, therefore bids must be in some seller-chosen unit (e.g. "USD per thousand").  If the bid is zero or negative, then this interest group will not participate in the seller's auction at all.  With this mechanism, the buyer can implement any advertiser rules for where their ads may or may not appear.
-*   bidCurrency: (optional) The currency for the bid, used for [currency-checking](#36-currency-checks).
+*   bidCurrency: (optional) The currency for the bid, used for [currency-checking](#36-currency-checking).
 *   render: A URL which will be rendered to display the creative if this bid wins the auction.
 *   adComponents: (optional) A list of up to 20 adComponent strings from the InterestGroup's adComponents field. Each value must match an adComponent renderURL exactly. This field must not be present if the InterestGroup has no adComponent field. It is valid for this field not to be present even when adComponents is present. (See ["Ads Composed of Multiple Pieces"](#34-ads-composed-of-multiple-pieces) below.)
 *   allowComponentAuction: If this buyer is taking part of a component auction, this value must be present and true, or the bid is ignored. This value is ignored (and may be absent) if the buyer is part of a top-level auction.
@@ -650,11 +650,11 @@ The `FilterOnDataFromServer` interest group will result in fetching `https://buy
 
 If participants in the auction need to deal with multiple currencies, they can optionally take advantage of automated currency checking. All of it operates on currency tags, which are required to contain 3 upper-case ASCII letters.
 
-If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for it is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as '???'.
+If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for it is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
 Checking inside `scoreAd` happens only inside component auctions.  If the auction modifies the bid, the modified version will be checked; if not, the passed-through bid from the original buyer will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
 
-`sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-multi-currency-reporting) for more details.
+`sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 
 ### 4. Browsers Render the Winning Ad
 
@@ -716,7 +716,7 @@ The arguments to this function are:
       'highestScoringOtherBidCurrency': ...
     }
     ```
-    * `bidCurrency` and `highestScoringOtherBidCurrency` provide (highly redacted) information on what currency the corresponding numbers are in. Please refer to the section on [Reporting in Multi-Currency Auctions](#53-multi-currency-reporting) for more details.
+    * `bidCurrency` and `highestScoringOtherBidCurrency` provide (highly redacted) information on what currency the corresponding numbers are in. Please refer to the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 *   directFromSellerSignals is an object that may contain the following fields:
     *   sellerSignals: Like auctionConfig.sellerSignals, but passed via the [directFromSellerSignals](#25-additional-trusted-signals-directfromsellersignals) mechanism. These are the signals whose subresource URL ends in `?sellerSignals`.
     *   auctionSignals: Like auctionConfig.auctionSignals, but passed via the [directFromSellerSignals](#25-additional-trusted-signals-directfromsellersignals) mechanism. These are the signals whose subresource URL ends in `?auctionSignals`.
@@ -779,7 +779,7 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to '???', with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`.
+If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to `'???'`, with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`.
 
 If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, the value used for reporting and private aggregation is zero.  In this mode, all APIs like event reporting, debug event-level loss reporting, and private aggregation will see the converted values, with the `sellerCurrency` as the appropriate currency tag, except the invocation of `reportWin()` (but not private aggregation triggered off `reportWin()` will once again see its own value and currency for `bid` and `bidCurrency` (but not `highestScoringOtherBid` and `highestScoringOtherBidCurrency`).
 
diff --git a/Proposed_First_FLEDGE_OT_Details.md b/Proposed_First_FLEDGE_OT_Details.md
index 92a6424c8..d55919041 100644
--- a/Proposed_First_FLEDGE_OT_Details.md
+++ b/Proposed_First_FLEDGE_OT_Details.md
@@ -61,13 +61,13 @@ As the FLEDGE explainer talks about, the FOT#1 will include event-level reportin
 The FOT#1 will include event-level reporting for both winning and losing bids. Implementations of the `generateBid()` and `scoreAd()` worklets, provided by the buyers and sellers respectively in the auction, may call a `forDebuggingOnly.reportAdAuctionLoss()` API which takes a single string argument representing a URL. The text placeholders below will be replaced with the corresponding value from the auction when found in the reporting URL's query parameters (note that due to http://crbug.com/1338233, prior to Chrome version 107.0.5286.0, the replacements only took place in the path of the URL)
 
 *   “${winningBid}” - The value of the winning bid.  In component auctions, this value comes from the component auction and not the top-level auction.
-*   “${winningBidCurrency}” - The currency `winningBid` is in. This is '???' if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
+*   “${winningBidCurrency}” - The currency `winningBid` is in. This is `'???'` if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
 *   “${madeWinningBid}” - A boolean value representing whether the owner of this interest group made the winning bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${highestScoringOtherBid}” - The value of the bid  that was scored as second highest by the seller’s scoreAd script. Note that this may not be the second highest bid value, since scores and bids may be independent.  In component auctions, this value comes from the component auction and not the top-level auction.
-*   “${highestScoringOtherBidCurrency}” - The currency `highestScoringOtherBid` is in. This is '???' if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
+*   “${highestScoringOtherBidCurrency}” - The currency `highestScoringOtherBid` is in. This is `'???'` if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
 *   “${madeHighestScoringOtherBid}” - A boolean value representing whether the owner of this interest group made the ${highestScoringOtherBid} bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${topLevelWinningBid}” - The value of the bid that won the top-level auction.  This value is only reported in component auctions.
-*   “${topLevelWinningBidCurrency}” - The currency `topLevelWinningBid` is in. This is '???' if it's in whatever currency the component auction made the bid in, or is a currency tag if it's in top-level auction's seller currency.
+*   “${topLevelWinningBidCurrency}” - The currency `topLevelWinningBid` is in. This is `'???'` if it's in whatever currency the component auction made the bid in, or is a currency tag if it's in top-level auction's seller currency.
 *   “${topLevelMadeWinningBid}” - A boolean value representing whether the owner of this interest group made the bid that won the top-level auction, either via this interest group, or another interest group with the same owner. This value is only reported in component auctions.
 
 If the bid being generated or scored loses the auction, the URL will be fetched. These worklets may also call a `forDebuggingOnly.reportAdAuctionWin()` API which operates similarly to `forDebuggingOnly.reportAdAuctionLoss()` API but only fetches the URL after a winning bid or score.

From 6b218f49af4f4df4ec25723e0898d09e815891fd Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@google.com>
Date: Mon, 8 May 2023 14:20:19 -0400
Subject: [PATCH 03/16] One more bit of formatting

---
 FLEDGE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 4b5af2725..ceefe4450 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -652,7 +652,7 @@ If participants in the auction need to deal with multiple currencies, they can o
 
 If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for it is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
-Checking inside `scoreAd` happens only inside component auctions.  If the auction modifies the bid, the modified version will be checked; if not, the passed-through bid from the original buyer will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
+Checking inside `scoreAd()` happens only inside component auctions.  If the auction modifies the bid, the modified version will be checked; if not, the passed-through bid from the original buyer will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
 
 `sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 

From 2f99becb3429895e0932483071334ef4906a9db0 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Fri, 12 May 2023 10:24:47 -0400
Subject: [PATCH 04/16] Edit redaction rule for reportWin

---
 FLEDGE.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index ceefe4450..0f60a2e87 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -779,9 +779,9 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to `'???'`, with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`.
+If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to `'???'`, with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`, which gets the entry corresponding to it in `perBuyerCurrencies` if available, or `'???'` otherwise.
 
-If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, the value used for reporting and private aggregation is zero.  In this mode, all APIs like event reporting, debug event-level loss reporting, and private aggregation will see the converted values, with the `sellerCurrency` as the appropriate currency tag, except the invocation of `reportWin()` (but not private aggregation triggered off `reportWin()` will once again see its own value and currency for `bid` and `bidCurrency` (but not `highestScoringOtherBid` and `highestScoringOtherBidCurrency`).
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, the value used for reporting and private aggregation is zero.  In this mode, all APIs like event-level reporting, debug event-level loss reporting, and private aggregation will see the converted values, with the `sellerCurrency` as the appropriate currency tag, except the invocation of `reportWin()` (but not private aggregation triggered off `reportWin()`) will once again see its own value for `bid` and its setting in `perBuyerCurrencies` for `bidCurrency` (but not `highestScoringOtherBid` and `highestScoringOtherBidCurrency`, which will still be in `sellerCurrency`, since they may be from a different bidder).
 
 Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
 

From 786a036642101bac94f02837b33af86f391b1278 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Tue, 23 May 2023 12:59:25 -0400
Subject: [PATCH 05/16] Apply some feedback

---
 FLEDGE.md                       | 10 +++++-----
 FLEDGE_extended_PA_reporting.md |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 0f60a2e87..acd96e669 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -379,7 +379,7 @@ Seller scripts in component auctions behave a little differently.  They still ex
 * desirability: Numeric score of the bid. Must be positive or the ad will be rejected.
 * allowComponentAuction: If this field is not true, the bid will be rejected.
 * bid: (optional) Modified bid value to provide to the top-level seller script. If present, this will be passed to the top-level seller's `scoreAd()` and `reportResult()` methods instead of the original bid, if the ad wins the component auction and top-level auction, respectively.
-* bidCurrency: (optional) Annotates the currency of the modified bid provided by bid. Please see the [Currency Checking section](#36-currency-checking)
+* bidCurrency: (optional) Annotates the currency of the modified bid provided by `bid`. Please see the [Currency Checking section](#36-currency-checking)
 
 Once all of a component auction's bids have been scored by the component auction's seller script, the bid with the highest score is passed to the top-level seller to score. For that bid, the top-level seller's `scoreAd()` method is passed the `ad` value from the component auction seller's `scoreAd()` method, and there is an additional `componentSeller` field in the `browserSignals`, which is the seller for the component auction. All other values are the same as if the bid had come from an interest group participating directly in the top-level auction. In the case of a tie, one of the highest scoring bids will be chosen randomly and only that bid will be passed to the top-level seller to score. The seller of a component auction may reject all bids by giving them scores <= 0. In that case, no bid from that component auction will be passed to the top-level auction.
 
@@ -650,9 +650,9 @@ The `FilterOnDataFromServer` interest group will result in fetching `https://buy
 
 If participants in the auction need to deal with multiple currencies, they can optionally take advantage of automated currency checking. All of it operates on currency tags, which are required to contain 3 upper-case ASCII letters.
 
-If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for it is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
+If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
-Checking inside `scoreAd()` happens only inside component auctions.  If the auction modifies the bid, the modified version will be checked; if not, the passed-through bid from the original buyer will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
+Currency checking after `scoreAd()` happens only inside component auctions.  If `scoreAd()` modifies the bid, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
 
 `sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 
@@ -707,13 +707,13 @@ The arguments to this function are:
       'interestGroupOwner': 'https://www.example-dsp.com/',
       'renderURL': 'https://cdn.com/url-of-winning-creative.wbn',
       'bid': bidValue,
-      'bidCurrency': ...,
+      'bidCurrency': 'USD',
       'desirability': desirabilityScoreForWinningAd,
       'topLevelSellerSignals': outputOfTopLevelSellersReportResult,
       'dataVersion': versionFromKeyValueResponse,
       'modifiedBid': modifiedBidValue,
       'highestScoringOtherBid': highestScoringOtherBidValue,
-      'highestScoringOtherBidCurrency': ...
+      'highestScoringOtherBidCurrency': 'EUR'
     }
     ```
     * `bidCurrency` and `highestScoringOtherBidCurrency` provide (highly redacted) information on what currency the corresponding numbers are in. Please refer to the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
diff --git a/FLEDGE_extended_PA_reporting.md b/FLEDGE_extended_PA_reporting.md
index 204be2e43..f867da829 100644
--- a/FLEDGE_extended_PA_reporting.md
+++ b/FLEDGE_extended_PA_reporting.md
@@ -204,8 +204,8 @@ Where `signalBucket` and `signalValue` is a dictionary which consists of:
     * 6: indicates seller rejected bid because “Creative Filtered - Language Exclusions”
     * 7: indicates seller rejected bid because “Creative Filtered - Category Exclusions”
     * 8: indicates seller rejected bid because "Creative Filtered - Did Not Meet The K-anonymity Threshold"
-    * 9: indicates bid produced by generateBid() was rejected because it failed a currency check
-    * 10: indicates bid passed through or altered by scoreAd() was rejected because it failed a currency check
+    * 9: indicates bid produced by `generateBid()` was rejected because it failed a currency check
+    * 10: indicates bid passed through or altered by `scoreAd()` was rejected because it failed a currency check
     * Perhaps other values indicating:
       * generateBid() hitting timeout
       * The auction was aborted (i.e. calling endAdAuction())

From 35d698c6410a424fca5334bc8fd31c9f2f14c570 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Wed, 31 May 2023 13:34:27 -0400
Subject: [PATCH 06/16] Update based on feedback

---
 FLEDGE.md | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index acd96e669..2f0ca0ea6 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -779,9 +779,15 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-If `sellerCurrency` is not set, all bids are passed as-is. Since passing currency tags around could leak an unacceptable amount of information, the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are also redacted to `'???'`, with the exception of the winning bid (but not `highestScoringOtherBid`) passed to `reportWin()`, which gets the entry corresponding to it in `perBuyerCurrencies` if available, or `'???'` otherwise.
+Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction). Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration in this context, or `'???'` if there isn't one.
 
-If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, the value used for reporting and private aggregation is zero.  In this mode, all APIs like event-level reporting, debug event-level loss reporting, and private aggregation will see the converted values, with the `sellerCurrency` as the appropriate currency tag, except the invocation of `reportWin()` (but not private aggregation triggered off `reportWin()`) will once again see its own value for `bid` and its setting in `perBuyerCurrencies` for `bidCurrency` (but not `highestScoringOtherBid` and `highestScoringOtherBidCurrency`, which will still be in `sellerCurrency`, since they may be from a different bidder).
+(Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
+
+All other values, including `highestScoringOtherBid` and winning bids provided to private aggregation and debug event-level loss reporting depend on the `sellerCurrency` setting.
+
+If `sellerCurrency` is not set, all bids in those other ("mixed currency") contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
+
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used. All currency tags for reporting in those "mixed currency" contexts will be set to `sellerCurrency`.
 
 Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
 

From 964e698e7dc863e6f66a9a8e7f18ba61465bfb78 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Wed, 31 May 2023 13:54:51 -0400
Subject: [PATCH 07/16] Also mention rounding

---
 FLEDGE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 2f0ca0ea6..f741717ca 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -779,7 +779,7 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction). Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration in this context, or `'???'` if there isn't one.
+Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration in this context, or `'???'` if there isn't one.
 
 (Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
 

From 8ceb67d1667b295719da7e4afd50385e1bb03944 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Mon, 7 Aug 2023 10:13:06 -0400
Subject: [PATCH 08/16] Apply a whole bunch of feedback

---
 FLEDGE.md                       | 6 +++---
 FLEDGE_extended_PA_reporting.md | 8 ++++++--
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index f6cf97e2d..2d2e41075 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -686,7 +686,7 @@ The `FilterOnDataFromServer` interest group will result in fetching `https://buy
 
 If participants in the auction need to deal with multiple currencies, they can optionally take advantage of automated currency checking. All of it operates on currency tags, which are required to contain 3 upper-case ASCII letters.
 
-If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the configuration and the returned tag must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
+If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the `perBuyerCurrencies` for that buyer and returned `bidCurrency` must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
 Currency checking after `scoreAd()` happens only inside component auctions.  If `scoreAd()` modifies the bid, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
 
@@ -816,7 +816,7 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration in this context, or `'???'` if there isn't one.
+Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
 
 (Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
 
@@ -824,7 +824,7 @@ All other values, including `highestScoringOtherBid` and winning bids provided t
 
 If `sellerCurrency` is not set, all bids in those other ("mixed currency") contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
 
-If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in proper currency nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used. All currency tags for reporting in those "mixed currency" contexts will be set to `sellerCurrency`.
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used for reporting in mixed-currency contexts. All currency tags for reporting in those "mixed currency" contexts will be set to `sellerCurrency`.
 
 Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
 
diff --git a/FLEDGE_extended_PA_reporting.md b/FLEDGE_extended_PA_reporting.md
index 7ae0dcffe..fc015ff57 100644
--- a/FLEDGE_extended_PA_reporting.md
+++ b/FLEDGE_extended_PA_reporting.md
@@ -204,8 +204,12 @@ Where `signalBucket` and `signalValue` is a dictionary which consists of:
     * 6: indicates seller rejected bid because “Creative Filtered - Language Exclusions”
     * 7: indicates seller rejected bid because “Creative Filtered - Category Exclusions”
     * 8: indicates seller rejected bid because "Creative Filtered - Did Not Meet The K-anonymity Threshold"
-    * 9: indicates bid produced by `generateBid()` was rejected because it failed a currency check
-    * 10: indicates bid passed through or altered by `scoreAd()` was rejected because it failed a currency check
+    * 9: indicates bid produced by `generateBid()` was rejected because it failed a currency check (e.g. the bid returned by `generateBid()` doesn't match
+    what's specified by `perBuyerCurrency`)
+    * 10: indicates bid passed through or altered by `scoreAd()` was rejected
+    because it failed a currency check (e.g. the bid returned or passed through
+    by `scoreAd()` in a component auction doesn't match the `sellerCurrency` of
+    its auction or the `perBuyerCurrency` required by the top-level auction)
     * Perhaps other values indicating:
       * generateBid() hitting timeout
       * The auction was aborted (i.e. calling endAdAuction())

From 572fda8ecc941f7d7e1f6e0dfcda4bf8866fbe2e Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@google.com>
Date: Wed, 6 Sep 2023 09:38:02 -0400
Subject: [PATCH 09/16] Apply suggestions from code review

Co-authored-by: Paul Jensen <JensenPaul@users.noreply.github.com>
---
 FLEDGE.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 2d2e41075..ff915c5f3 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -688,7 +688,7 @@ If participants in the auction need to deal with multiple currencies, they can o
 
 If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the `perBuyerCurrencies` for that buyer and returned `bidCurrency` must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
-Currency checking after `scoreAd()` happens only inside component auctions.  If `scoreAd()` modifies the bid, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction.  As before, both the bid and the configuration in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the component auction.
+Currency checking after `scoreAd()` happens only inside component auctions.  If the component seller's `scoreAd()` modifies the bid value, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction's seller.  As before, both the bid currency and the configured currency in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the top-level auction.
 
 `sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 
@@ -816,7 +816,7 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
+Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction seller's `scoreAd()`), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
 
 (Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
 

From ceaccf27b6e077fd655839a296d7e28c10b014e8 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Wed, 6 Sep 2023 11:00:46 -0400
Subject: [PATCH 10/16] Adjust some phrasing

---
 FLEDGE.md                           | 2 ++
 Proposed_First_FLEDGE_OT_Details.md | 7 ++++---
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index ff915c5f3..61a1125bb 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -362,6 +362,8 @@ scoreAd(adMetadata, bid, auctionConfig, trustedScoringSignals, browserSignals,
     directFromSellerSignals) {
   ...
   return {desirability: desirabilityScoreForThisAd,
+          incomingBidInSellerCurrency:
+              convertToEuros(bid, browserSignals.bidCurrency),
           allowComponentAuction: componentAuctionsAllowed};
 }
 ```
diff --git a/Proposed_First_FLEDGE_OT_Details.md b/Proposed_First_FLEDGE_OT_Details.md
index c2fd1126a..b0590a7c7 100644
--- a/Proposed_First_FLEDGE_OT_Details.md
+++ b/Proposed_First_FLEDGE_OT_Details.md
@@ -61,13 +61,14 @@ As the FLEDGE explainer talks about, the FOT#1 will include event-level reportin
 The FOT#1 will include event-level reporting for both winning and losing bids. Implementations of the `generateBid()` and `scoreAd()` worklets, provided by the buyers and sellers respectively in the auction, may call a `forDebuggingOnly.reportAdAuctionLoss()` API which takes a single string argument representing a URL. The text placeholders below will be replaced with the corresponding value from the auction when found in the reporting URL's query parameters (note that due to http://crbug.com/1338233, prior to Chrome version 107.0.5286.0, the replacements only took place in the path of the URL)
 
 *   “${winningBid}” - The value of the winning bid.  In component auctions, this value comes from the component auction and not the top-level auction.
-*   “${winningBidCurrency}” - The currency `winningBid` is in. This is `'???'` if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
+*   “${winningBidCurrency}” - If the auction has a `sellerCurrency` configured, this will be its currency tag; otherwise it is `'???'` to denote that it's in bidder's original currency.
 *   “${madeWinningBid}” - A boolean value representing whether the owner of this interest group made the winning bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${highestScoringOtherBid}” - The value of the bid  that was scored as second highest by the seller’s scoreAd script. Note that this may not be the second highest bid value, since scores and bids may be independent.  In component auctions, this value comes from the component auction and not the top-level auction.
-*   “${highestScoringOtherBidCurrency}” - The currency `highestScoringOtherBid` is in. This is `'???'` if it's in bidder's original currency, or is a currency tag if it's in seller's currency.
+*   “${highestScoringOtherBidCurrency}” - The currency `highestScoringOtherBid` is in. If the auction has a `sellerCurrency` configured, this will be its currency tag; otherwise it is `'???'` to denote that it's in bidder's original currency.
 *   “${madeHighestScoringOtherBid}” - A boolean value representing whether the owner of this interest group made the ${highestScoringOtherBid} bid, either via this interest group, or another interest group with the same owner.  In component auctions, this value comes from the component auction and not the top-level auction.
 *   “${topLevelWinningBid}” - The value of the bid that won the top-level auction.  This value is only reported in component auctions.
-*   “${topLevelWinningBidCurrency}” - The currency `topLevelWinningBid` is in. This is `'???'` if it's in whatever currency the component auction made the bid in, or is a currency tag if it's in top-level auction's seller currency.
+*   “${topLevelWinningBidCurrency}” - The currency `topLevelWinningBid` is in.
+If the top-level auction has a `sellerCurrency` configured, this will be its currency tag; otherwise it is `'???'` to denote that it's in whatever currency the component auction made the bid in.
 *   “${topLevelMadeWinningBid}” - A boolean value representing whether the owner of this interest group made the bid that won the top-level auction, either via this interest group, or another interest group with the same owner. This value is only reported in component auctions.
 
 If the bid being generated or scored loses the auction, the URL will be fetched. These worklets may also call a `forDebuggingOnly.reportAdAuctionWin()` API which operates similarly to `forDebuggingOnly.reportAdAuctionLoss()` API but only fetches the URL after a winning bid or score.

From d218357e03bc9344169e2cdec2dea592bda329c8 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Mon, 16 Oct 2023 10:47:45 -0400
Subject: [PATCH 11/16] Apply feedback

---
 FLEDGE.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 61a1125bb..42f2acbbe 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -688,9 +688,9 @@ The `FilterOnDataFromServer` interest group will result in fetching `https://buy
 
 If participants in the auction need to deal with multiple currencies, they can optionally take advantage of automated currency checking. All of it operates on currency tags, which are required to contain 3 upper-case ASCII letters.
 
-If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the `perBuyerCurrencies` for that buyer and returned `bidCurrency` must be present for checking to take place.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
+If the `generateBid()` method returns a `bidCurrency`, and the `perBuyerCurrencies` for that buyer is specified, their consistency will be checked, and if there is a mismatch, the bid will be dropped.  Both the `perBuyerCurrencies` for that buyer and returned `bidCurrency` must be present for checking to take place; if one or both are missing the currency check does not take place and the bid is passed on as-is.  The returned `bidCurrency` will be passed to `scoreAd()`'s `browserSignals.bidCurrency`, with unspecified currency rendered as `'???'`.
 
-Currency checking after `scoreAd()` happens only inside component auctions.  If the component seller's `scoreAd()` modifies the bid value, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction's seller.  As before, both the bid currency and the configured currency in question must be specified for the checking to take place. If there is a mismatch, the bid will not take part in the top-level auction.
+Currency checking after `scoreAd()` happens only inside component auctions.  If the component seller's `scoreAd()` modifies the bid value, the modified bid's currency will be checked; if not, the passed-through bid from the original buyer's currency will be. In either case, the currency will be checked both against the component auction's `sellerCurrency` and top-level auction's `perBuyerCurrencies` as applied to the component auction's seller.  As before, both the bid currency and the configured currency in question must be specified for the checking to take place; if one or both are missing that particular currency check does not take place. If there is a mismatch, the bid will not take part in the top-level auction.
 
 `sellerCurrency` also has an extensive effect on how reporting behaves.  Please see the section on [Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions) for more details.
 
@@ -822,11 +822,11 @@ Regardless of configuration, the bid passed to `reportWin()` and `reportResult()
 
 (Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
 
-All other values, including `highestScoringOtherBid` and winning bids provided to private aggregation and debug event-level loss reporting depend on the `sellerCurrency` setting.
+All other values, including `highestScoringOtherBid` and winning bids provided to private aggregation and debug event-level loss reporting depend on the `sellerCurrency` setting. We refer to those usages as "potentially mixed currency" contexts, as they can involve information from multiple bids, and hence potentially multiple currencies.
 
-If `sellerCurrency` is not set, all bids in those other ("mixed currency") contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
+If `sellerCurrency` is not set, all bids in potentially mixed currency contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
 
-If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency can not be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used for reporting in mixed-currency contexts. All currency tags for reporting in those "mixed currency" contexts will be set to `sellerCurrency`.
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency cannot be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used for reporting in potentially mixed currency contexts. All currency tags for reporting in those potentially mixed currency contexts will be set to `sellerCurrency`.
 
 Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
 

From a7a6787988530dc86b5b2a7ba737ece503be2ef1 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@google.com>
Date: Mon, 23 Oct 2023 12:19:35 -0400
Subject: [PATCH 12/16] Apply suggestions from code review

Co-authored-by: Paul Jensen <JensenPaul@users.noreply.github.com>
---
 FLEDGE.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 42f2acbbe..07a1cf367 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -818,13 +818,13 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-Regardless of configuration, the bid passed to `reportWin()` and `reportResult()` is always the bid that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid altered by the component auction seller's `scoreAd()`), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
+Regardless of configuration, the bid price passed to `reportWin()` and `reportResult()` is always the bid price that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid price altered by the component auction seller's `scoreAd()`), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
 
 (Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
 
 All other values, including `highestScoringOtherBid` and winning bids provided to private aggregation and debug event-level loss reporting depend on the `sellerCurrency` setting. We refer to those usages as "potentially mixed currency" contexts, as they can involve information from multiple bids, and hence potentially multiple currencies.
 
-If `sellerCurrency` is not set, all bids in potentially mixed currency contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
+If `sellerCurrency` is not set, all bid prices in potentially mixed currency contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
 
 If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency cannot be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used for reporting in potentially mixed currency contexts. All currency tags for reporting in those potentially mixed currency contexts will be set to `sellerCurrency`.
 

From 91cbbb4e719c2b28220cf682606ebdfaf8e95935 Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Thu, 26 Oct 2023 13:29:37 -0400
Subject: [PATCH 13/16] Tablification attempt, not sure if ready for review

---
 FLEDGE.md | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 07a1cf367..49f9198bc 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -818,18 +818,29 @@ In auctions that involve multiple currencies, there may be values with different
 
 To help deal with this scenario, an optional mode is available that converts all bid-related information to seller's preferred currency (in component auctions, reporting for it is for that component's seller). This is configured via the `sellerCurrency` setting in each auction configuration.
 
-Regardless of configuration, the bid price passed to `reportWin()` and `reportResult()` is always the bid price that participated in that particular level of the auction (which, for top-level auction `reportResult()`, may be the bid price altered by the component auction seller's `scoreAd()`), subject to the usual rounding rules. Since passing the returned currency tags around could leak an unacceptable amount of information, the values provided for `browserSignals.bidCurrency` to those methods are the currencies required by the auction configuration (i.e. `sellerCurrency` and `perBuyerCurrencies`), or `'???'` if unspecified.
-
-(Warning: `reportResult` did not follow this rule in Chrome earlier than M116)
-
-All other values, including `highestScoringOtherBid` and winning bids provided to private aggregation and debug event-level loss reporting depend on the `sellerCurrency` setting. We refer to those usages as "potentially mixed currency" contexts, as they can involve information from multiple bids, and hence potentially multiple currencies.
-
-If `sellerCurrency` is not set, all bid prices in potentially mixed currency contexts are passed as-is, and all the corresponding currency tags (`bidCurrency`, `highestScoringOtherBidCurrency`) are redacted to `'???'`.
-
-If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in that currency to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency cannot be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used for reporting in potentially mixed currency contexts. All currency tags for reporting in those potentially mixed currency contexts will be set to `sellerCurrency`.
+If `sellerCurrency` is set, `scoreAd()` for an auction is responsible for converting bids not already in `sellerCurrency` to `sellerCurrency`, via the `incomingBidInSellerCurrency` field of its return value. A bid already explicitly in the seller's currency cannot be changed by `incomingBidInSellerCurrency`.  If neither the original bid is explicitly in `sellerCurrency` nor an `incomingBidInSellerCurrency` is specified, a value of 0 is used as the converted value.
 
 Note that `incomingBidInSellerCurrency` is different from the modified bid returned by a component auction: it represents a mechanical currency translation of the original buyer's bid, rather than the bid the component auction is making in a top-level auction (which could, perhaps, be reduced by the intermediate seller's fee or the like). It can also be specified in top-level auctions, unlike the modified bid.
 
+The following table summarizes which APIs get original and which get converted bid values, and how redaction for currency tags works, depending on whether `sellerCurrency` is set or not:
+| API | when `sellerCurrency` unset | when `sellerCurrency` set |
+| --- | --- | --- |
+|`reportWin()` `browserSignals.bid` | Original value | Same |
+|`reportWin()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Same |
+|`reportResult()` `browserSignals.bid` | Original value of bid at that auction level (for top-level auction this includes any modification by component-auction)  | Same (in Chrome since M116) |
+|`reportResult()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Same (in Chrome since M116) |
+|`reportWin()` browserSignals.highestScoringOtherBid | Original value | Converted value |
+|`reportWin()` browserSignals.highestScoringOtherBidCurrency | `'???'` | `sellerCurrency` |
+|`reportResult()` browserSignals.highestScoringOtherBid | Original value | Converted value |
+|`reportResult()` browserSignals.highestScoringOtherBidCurrency | `'???'` | `sellerCurrency` |
+| `forDebuggingOnly.report...` keyword `${winningBid}` | Original value | Converted value |
+| `forDebuggingOnly.report...` keyword `${winningBidCurrency}` | `'???'` | `sellerCurrency`|
+| `forDebuggingOnly.report...` keyword `${highestScoringOtherBid}` | Original value | Converted value |
+| `forDebuggingOnly.report...` keyword `${highestScoringOtherBidCurrency}` | `'???'` | `sellerCurrency`|
+| `forDebuggingOnly.report...` keyword `${topLevelWinningBid}` | Original value | Converted value (as converted by top-level `scoreAd()`) |
+| `forDebuggingOnly.report...` keyword `${topLevelWinningBidCurrency}` | `'???'` | `sellerCurrency` of top-level auction |
+| Private Aggregation `winning-bid` | Original value | Converted value |
+| Private Aggregation `highest-scoring-other-bid` | Original value | Converted value |
 
 #### 5.4 Losing Bidder Reporting
 

From e356ffa1b8d1d0a70a12abb8a85f79d78c4151af Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Fri, 27 Oct 2023 12:47:50 -0400
Subject: [PATCH 14/16] Be explicit rather than "same"

---
 FLEDGE.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 357667939..def0650b3 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -923,10 +923,10 @@ Note that `incomingBidInSellerCurrency` is different from the modified bid retur
 The following table summarizes which APIs get original and which get converted bid values, and how redaction for currency tags works, depending on whether `sellerCurrency` is set or not:
 | API | when `sellerCurrency` unset | when `sellerCurrency` set |
 | --- | --- | --- |
-|`reportWin()` `browserSignals.bid` | Original value | Same |
-|`reportWin()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Same |
-|`reportResult()` `browserSignals.bid` | Original value of bid at that auction level (for top-level auction this includes any modification by component-auction)  | Same (in Chrome since M116) |
-|`reportResult()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Same (in Chrome since M116) |
+|`reportWin()` `browserSignals.bid` | Original value | Original value |
+|`reportWin()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Currency required by auction configuration, or `'???'` |
+|`reportResult()` `browserSignals.bid` | Original value of bid at that auction level (for top-level auction this includes any modification by component auction)  | Original value of bid at that auction level (for top-level auction this includes any modification by component auction) (in Chrome since M116) |
+|`reportResult()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Currency required by auction configuration, or `'???'` (in Chrome since M116) |
 |`reportWin()` browserSignals.highestScoringOtherBid | Original value | Converted value |
 |`reportWin()` browserSignals.highestScoringOtherBidCurrency | `'???'` | `sellerCurrency` |
 |`reportResult()` browserSignals.highestScoringOtherBid | Original value | Converted value |

From a92d7323428797b45db95d81719495ec11eaf23b Mon Sep 17 00:00:00 2001
From: Maks Orlovich <morlovich@chromium.org>
Date: Wed, 1 Nov 2023 09:43:18 -0400
Subject: [PATCH 15/16] Make the reporting section somewhat more generic, based
 on feedback from Matt.

---
 FLEDGE.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index def0650b3..b80709d85 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -36,7 +36,7 @@ See [the Protected Audience API specification](https://wicg.github.io/turtledove
     - [5.1 Seller Reporting on Render](#51-seller-reporting-on-render)
     - [5.2 Buyer Reporting on Render and Ad Events](#52-buyer-reporting-on-render-and-ad-events)
       - [5.2.1 Noised and Bucketed Signals](#521-noised-and-bucketed-signals)
-    - [5.3 Reporting in Multi-Currency Auctions](#53-reporting-in-multi-currency-auctions)
+    - [5.3 Currencies in Reporting](#53-currencies-in-reporting)
     - [5.4 Losing Bidder Reporting](#54-losing-bidder-reporting)
   - [6. Additional Bids](#6-additional-bids)
     - [6.1 Auction Nonce](#61-auction-nonce)
@@ -368,7 +368,7 @@ Optionally, `sellerExperimentGroupId` can be specified by the seller to support
 
 Optionally, `perBuyerPrioritySignals` is an object mapping string keys to Javascript numbers that can be used to dynamically compute interest group priorities before `perBuyerGroupLimits` are applied. See [Filtering and Prioritizing Interest Groups](#35-filtering-and-prioritizing-interest-groups) for more information.
 
-Optionally, `perBuyerCurrencies` and `sellerCurrency` are used for [currency-checking](#36-currency-checking). `sellerCurrency` is also used to [homogenize reporting in multi-currency auctions](#53-reporting-in-multi-currency-auctions).
+Optionally, `perBuyerCurrencies` and `sellerCurrency` are used for [currency-checking](#36-currency-checking). `sellerCurrency` also affects how [currencies behave in reporting](#53-currencies-in-reporting).
 
 Optionally, `resolveToConfig` is a boolean directing the promise returned from `runAdAuction()` to resolve to a `FencedFrameConfig` if true, for use in a `<fencedframe>`, or if false to an opaque `urn:uuid` URL, for use in an `<iframe>`.  If `resolveToConfig` is not set, it defaults to false.
 If the `window.FencedFrameConfig` interface is not exposed (because e.g., the script is running in an older version of Chrome that does not yet implement `FencedFrameConfig`, then the auction will _always_ yield a URN.
@@ -910,7 +910,7 @@ When `joinCount` is passed to `generateBid()`, no noising or bucketing is applie
 
 These signals were requested in [issue 435](https://github.com/WICG/turtledove/issues/435). The signals are intented to ship in Chrome M114, they will no longer be available for event level reporting when event level reporting is retired.
 
-#### 5.3 Reporting in Multi-Currency Auctions
+#### 5.3 Currencies in Reporting
 
 In auctions that involve multiple currencies, there may be values with different units floating around, which makes aggregated information incomprehensible, and event-level information hard to process, potentially requiring participants to interpret currencies of jurisdictions they do no business in.
 

From 0aec74eff915f2a2965c86642a0275c802deb7a1 Mon Sep 17 00:00:00 2001
From: Paul Jensen <JensenPaul@users.noreply.github.com>
Date: Fri, 3 Nov 2023 08:39:51 -0400
Subject: [PATCH 16/16] add missing backticks

---
 FLEDGE.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/FLEDGE.md b/FLEDGE.md
index 92746ce81..324965636 100644
--- a/FLEDGE.md
+++ b/FLEDGE.md
@@ -955,10 +955,10 @@ The following table summarizes which APIs get original and which get converted b
 |`reportWin()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Currency required by auction configuration, or `'???'` |
 |`reportResult()` `browserSignals.bid` | Original value of bid at that auction level (for top-level auction this includes any modification by component auction)  | Original value of bid at that auction level (for top-level auction this includes any modification by component auction) (in Chrome since M116) |
 |`reportResult()` `browserSignals.bidCurrency` | Currency required by auction configuration, or `'???'` | Currency required by auction configuration, or `'???'` (in Chrome since M116) |
-|`reportWin()` browserSignals.highestScoringOtherBid | Original value | Converted value |
-|`reportWin()` browserSignals.highestScoringOtherBidCurrency | `'???'` | `sellerCurrency` |
-|`reportResult()` browserSignals.highestScoringOtherBid | Original value | Converted value |
-|`reportResult()` browserSignals.highestScoringOtherBidCurrency | `'???'` | `sellerCurrency` |
+|`reportWin()` `browserSignals.highestScoringOtherBid` | Original value | Converted value |
+|`reportWin()` `browserSignals.highestScoringOtherBidCurrency` | `'???'` | `sellerCurrency` |
+|`reportResult()` `browserSignals.highestScoringOtherBid` | Original value | Converted value |
+|`reportResult()` `browserSignals.highestScoringOtherBidCurrency` | `'???'` | `sellerCurrency` |
 | `forDebuggingOnly.report...` keyword `${winningBid}` | Original value | Converted value |
 | `forDebuggingOnly.report...` keyword `${winningBidCurrency}` | `'???'` | `sellerCurrency`|
 | `forDebuggingOnly.report...` keyword `${highestScoringOtherBid}` | Original value | Converted value |