From 6d4ca42c6e6c4224ce480be62ecc2eca9fb5d2ab Mon Sep 17 00:00:00 2001
From: Shawn Blackmore <blackmore.technology.group@gmail.com>
Date: Thu, 1 Oct 2026 14:32:25 -0700
Subject: [PATCH] fix: bind RFQ trades to signed EOPP source

---
 ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json       |  9 +--
 ENTITY_V3_EOPP_HARDENING_MANIFEST.json        | 13 ++--
 ENTITY_V3_MARKET_RECOVERY_MANIFEST.json       |  8 +--
 src/31_Profiles/exchange_protocol.py          | 15 +++-
 src/32_V3_Hardening/exchange_protocol.py      | 17 ++++-
 .../economic_participation.py                 | 66 +++++++++++++++--
 src/34_Market_Recovery/market_recovery.py     |  2 +-
 tests/test_v3_economic_participation.py       | 72 ++++++++++++++++++-
 8 files changed, 178 insertions(+), 24 deletions(-)

diff --git a/ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json b/ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json
index 89f8dfad..0a1f4ca1 100644
--- a/ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json
+++ b/ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json
@@ -34,11 +34,11 @@
   "files": [
     {
       "path": "src/31_Profiles/exchange_protocol.py",
-      "sha256": "cca451e553ea70a778c983805d155f05bb92baab5f481f75a60084a92e48d9f6"
+      "sha256": "53761f15c7ae58726ce8cd01a28164d3a14ae29aac38a89859c408fc3c76b14a"
     },
     {
       "path": "src/32_V3_Hardening/exchange_protocol.py",
-      "sha256": "a631e259d2f0d7e4c4abf3acf1c04586e22bf5072928e5f9a9ddc3c130713637"
+      "sha256": "767e2a83a7ab5a71256c4f9535b75d91e7d33c97aaa7b7cefc617ffa7874bf41"
     },
     {
       "path": "protocol/v3/ENTITY_EXCHANGE_PROTOCOL_DRAFT.md",
@@ -95,10 +95,11 @@
     "sell admission rechecks unreserved entitlement atomically under concurrent submissions",
     "concurrent matchers cannot create duplicate trades from the same executable orders",
     "concurrent settlement attempts commit at most one entitlement transfer",
-    "revenue-event persistence is atomic with hardening-profile settlement state"
+    "revenue-event persistence is atomic with hardening-profile settlement state",
+    "RFQ executions preserve a deterministic venue-signed source binding to signed RFQ, quote and acceptance records"
   ],
   "schema": "entity-v3-eep-conformance-manifest-v1",
-  "snapshot_sha256": "00b066155090b7612191852293429d00d76c996ccf00c122fc1f549f19f3cf53",
+  "snapshot_sha256": "65224aa97bde5456c4079097a37284ce6e023f3e1c635f25456683c74e3df91a",
   "status": "BTG_INTERNAL_QUALIFIED_RELEASE_COMPONENT",
   "version": "3.0.0",
   "working_tree_snapshot": false
diff --git a/ENTITY_V3_EOPP_HARDENING_MANIFEST.json b/ENTITY_V3_EOPP_HARDENING_MANIFEST.json
index d720e25d..1ef85fbc 100644
--- a/ENTITY_V3_EOPP_HARDENING_MANIFEST.json
+++ b/ENTITY_V3_EOPP_HARDENING_MANIFEST.json
@@ -11,7 +11,7 @@
   "files": [
     {
       "path": "src/33_Economic_Participation/economic_participation.py",
-      "sha256": "3d805ab601bbf46001175796b601c3c66190c704408f86beb21f942f1de6a9d5"
+      "sha256": "493268dcc2a2d4564172cb7039e74861bfe63d93734e8b4a1cb70b97dc390d66"
     },
     {
       "path": "src/33_Economic_Participation/btg_deployment.py",
@@ -19,7 +19,7 @@
     },
     {
       "path": "tests/test_v3_economic_participation.py",
-      "sha256": "35c376010c209108aa0c314f531c06739c8af929c0bfea6af1753d5452f1c093"
+      "sha256": "f181089a2ed983dca3dfe1fb6f2a4690b4e285db9ed5992006a4477ef285be4b"
     },
     {
       "path": "protocol/v3/ENTITY_ORIGINATOR_PARTICIPATION_PROFILE.md",
@@ -44,7 +44,8 @@
     "event_and_obligation_trade_reconciliation",
     "provider_receivable_without_payer_private_key",
     "derivative_currency_binding",
-    "expanded_normative_record_schema"
+    "expanded_normative_record_schema",
+    "rfq_signed_source_participation_capture"
   ],
   "invariants": {
     "cryptocurrency_required": false,
@@ -55,7 +56,7 @@
   },
   "preserved_sealed_manifest_sha256": "7dc3dcd40e69dff30c615e01ecea32a96ea81243a123f108167b3fd6d390ad66",
   "schema": "entity-v3-eopp-hardening-manifest-v1",
-  "snapshot_sha256": "6f787cf66a98f05eb9d43f5b2ef4d9ac94502cb9e084707ce060d146450a03a6",
+  "snapshot_sha256": "7f95bac570b5091346c2fa09a745e422e7b0449d8cf184d77c98ec4d65fdf503",
   "status": "BTG_INTERNAL_QUALIFIED_RELEASE_COMPONENT",
   "validation": {
     "complete_active_tree": {
@@ -63,8 +64,8 @@
       "total": 90
     },
     "targeted_eopp": {
-      "passed": 20,
-      "total": 20
+      "passed": 24,
+      "total": 24
     }
   },
   "version": "3.0.0",
diff --git a/ENTITY_V3_MARKET_RECOVERY_MANIFEST.json b/ENTITY_V3_MARKET_RECOVERY_MANIFEST.json
index 9a9beb1b..6a1fb7a1 100644
--- a/ENTITY_V3_MARKET_RECOVERY_MANIFEST.json
+++ b/ENTITY_V3_MARKET_RECOVERY_MANIFEST.json
@@ -11,7 +11,7 @@
   "files": [
     {
       "path": "src/34_Market_Recovery/market_recovery.py",
-      "sha256": "97d084fdcece2289a5860e6a16007c40f39cd95f27693c961d702fdd1b388cd9"
+      "sha256": "7a96f1e44b7910e7c1560074591c5a5dba208bd66d5e10702d828bd57b35e606"
     },
     {
       "path": "tests/test_v3_market_recovery.py",
@@ -27,11 +27,11 @@
     },
     {
       "path": "ENTITY_V3_EEP_CONFORMANCE_MANIFEST.json",
-      "sha256": "07700ba28c78f9d7d5c65f946fc5a320f05f32918721f0e9efda75f054d34053"
+      "sha256": "aa7dd20a8d396084ead3b677eda0251912cb7ccaf8a857bd54d1df84ec7679d1"
     },
     {
       "path": "ENTITY_V3_EOPP_HARDENING_MANIFEST.json",
-      "sha256": "ecbb035a6fef8accfd68ca36bd2e7425957420b47c7f387c17dfd84341bdb3c4"
+      "sha256": "25292ef3320e31243c0155ddf297c5b6908b8a8c4b50993b1c66c3aff8295403"
     }
   ],
   "implemented": [
@@ -49,7 +49,7 @@
     "required_trade_revenue_binding_recovery"
   ],
   "schema": "entity-v3-market-recovery-evidence-manifest-v1",
-  "snapshot_sha256": "6055a9bd4c4a3ae0968bd425dd8245f62a4ce5cd57fbb4399903366667b970de",
+  "snapshot_sha256": "947a0b9bf2aa60078ec990e28962392d428d4fd751a6e2cfebf4f26378abdfd3",
   "status": "BTG_INTERNAL_QUALIFIED_RELEASE_COMPONENT",
   "validation": {
     "complete_active_tree": {
diff --git a/src/31_Profiles/exchange_protocol.py b/src/31_Profiles/exchange_protocol.py
index 20b2213d..8121df30 100644
--- a/src/31_Profiles/exchange_protocol.py
+++ b/src/31_Profiles/exchange_protocol.py
@@ -191,6 +191,10 @@ def _init(self):
               acceptance_id TEXT PRIMARY KEY, rfq_id TEXT NOT NULL, quote_id TEXT NOT NULL,
               requester TEXT NOT NULL, nonce TEXT NOT NULL UNIQUE, created_at_ms INTEGER NOT NULL,
               received_at_ms INTEGER NOT NULL, signature_json TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS rfq_trade_sources(
+              trade_id TEXT PRIMARY KEY, rfq_id TEXT NOT NULL, quote_id TEXT NOT NULL,
+              acceptance_id TEXT NOT NULL, venue_operator TEXT NOT NULL,
+              created_at_ms INTEGER NOT NULL, signature_json TEXT NOT NULL);
             CREATE TABLE IF NOT EXISTS order_cancellations(
               cancellation_id TEXT PRIMARY KEY, order_id TEXT NOT NULL, participant TEXT NOT NULL,
               nonce TEXT NOT NULL UNIQUE, created_at_ms INTEGER NOT NULL,
@@ -877,6 +881,15 @@ def _record_signed_quote_acceptance(self, body: dict, signature: dict) -> dict:
                 buy_stub={"venue_id":rfq["venue_id"],"instrument_id":rfq["instrument_id"],"order_id":None,"participant":buyer}
                 sell_stub={"order_id":None,"participant":seller}
                 trade_id=self._execute_trade(db,buy_stub,sell_stub,int(rfq["quantity"]),int(quote["price"]),"RFQ")
+                venue=db.execute("SELECT * FROM venues WHERE venue_id=? AND status='ACTIVE'",(rfq["venue_id"],)).fetchone()
+                if not venue: raise KeyError("active RFQ venue missing")
+                source_created=now_ms()
+                source_body={"schema":"entity-eep-rfq-execution-source-v1","trade_id":trade_id,"venue_id":rfq["venue_id"],"instrument_id":rfq["instrument_id"],
+                             "rfq_id":body["rfq_id"],"quote_id":body["quote_id"],"acceptance_id":body["acceptance_id"],
+                             "requester":requester,"provider":quote["provider"],"buyer":buyer,"seller":seller,
+                             "quantity":int(rfq["quantity"]),"price":int(quote["price"]),"venue_operator":venue["operator"],"created_at_ms":source_created}
+                source_sig=self.identity.sign(venue["operator"],source_body)
+                db.execute("INSERT INTO rfq_trade_sources VALUES(?,?,?,?,?,?,?)",(trade_id,body["rfq_id"],body["quote_id"],body["acceptance_id"],venue["operator"],source_created,json.dumps(source_sig,sort_keys=True)))
                 db.execute("UPDATE rfqs SET status='ACCEPTED' WHERE rfq_id=?",(body["rfq_id"],))
                 db.execute("UPDATE quotes SET status='ACCEPTED' WHERE quote_id=?",(body["quote_id"],))
         except sqlite3.IntegrityError as exc: raise ValueError("duplicate/replayed RFQ acceptance") from exc
@@ -899,7 +912,7 @@ def surveillance_alerts(self, venue_id: str) -> list[dict]:
 
     def status(self) -> dict:
         with self._db() as db:
-            tables=("venues","instruments","listings","orders","order_cancellations","trades","clearing","payment_attestations","settlement_verifiers","entitlements","usage","surveillance","rfqs","quotes","rfq_acceptances","revenue_rule_sets","trade_revenue_bindings")
+            tables=("venues","instruments","listings","orders","order_cancellations","trades","clearing","payment_attestations","settlement_verifiers","entitlements","usage","surveillance","rfqs","quotes","rfq_acceptances","rfq_trade_sources","revenue_rule_sets","trade_revenue_bindings")
             counts={name:int(db.execute(f"SELECT COUNT(*) FROM {name}").fetchone()[0]) for name in tables}
         return {"schema":"entity-eep-status-v1","profile":"ENTITY_EXCHANGE_PROTOCOL","version":"3.0.0",
                 "rights_are_traded_not_bytes":True,"venue_neutral":True,"payment_versus_right_transfer":True,
diff --git a/src/32_V3_Hardening/exchange_protocol.py b/src/32_V3_Hardening/exchange_protocol.py
index a1c55d60..b9e74bb1 100644
--- a/src/32_V3_Hardening/exchange_protocol.py
+++ b/src/32_V3_Hardening/exchange_protocol.py
@@ -128,6 +128,7 @@ def _init(self):
             CREATE TABLE IF NOT EXISTS rfqs(rfq_id TEXT PRIMARY KEY,venue_id TEXT,instrument_id TEXT,requester TEXT,side TEXT,quantity INTEGER,expires_at_ms INTEGER,status TEXT,created_at_ms INTEGER,nonce TEXT,received_at_ms INTEGER,signature_json TEXT);
             CREATE TABLE IF NOT EXISTS quotes(quote_id TEXT PRIMARY KEY,rfq_id TEXT,provider TEXT,price INTEGER,expires_at_ms INTEGER,status TEXT,created_at_ms INTEGER,nonce TEXT,received_at_ms INTEGER,signature_json TEXT);
             CREATE TABLE IF NOT EXISTS rfq_acceptances(acceptance_id TEXT PRIMARY KEY,rfq_id TEXT NOT NULL,quote_id TEXT NOT NULL,requester TEXT NOT NULL,nonce TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,received_at_ms INTEGER NOT NULL,signature_json TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS rfq_trade_sources(trade_id TEXT PRIMARY KEY,rfq_id TEXT NOT NULL,quote_id TEXT NOT NULL,acceptance_id TEXT NOT NULL,venue_operator TEXT NOT NULL,created_at_ms INTEGER NOT NULL,signature_json TEXT NOT NULL);
             CREATE TABLE IF NOT EXISTS order_cancellations(cancellation_id TEXT PRIMARY KEY,order_id TEXT NOT NULL,participant TEXT NOT NULL,nonce TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,received_at_ms INTEGER NOT NULL,signature_json TEXT NOT NULL);
             CREATE TABLE IF NOT EXISTS settlement_verifiers(venue_id TEXT NOT NULL,verifier_entity_id TEXT NOT NULL,status TEXT NOT NULL,created_at_ms INTEGER NOT NULL,signature_json TEXT NOT NULL,PRIMARY KEY(venue_id,verifier_entity_id));
             CREATE TABLE IF NOT EXISTS payment_attestations(attestation_id TEXT PRIMARY KEY,trade_id TEXT NOT NULL,verifier_entity_id TEXT NOT NULL,settlement_ref TEXT NOT NULL,evidence_sha256 TEXT NOT NULL,nonce TEXT NOT NULL UNIQUE,created_at_ms INTEGER NOT NULL,received_at_ms INTEGER NOT NULL,authority_basis TEXT NOT NULL,signature_json TEXT NOT NULL);
@@ -575,10 +576,20 @@ def _record_signed_quote_acceptance(self,body,signature):
                 if available<int(rfq['quantity']): raise PermissionError('RFQ seller lacks unreserved entitlement')
                 db.execute('INSERT INTO rfq_acceptances VALUES(?,?,?,?,?,?,?,?)',(
                     body['acceptance_id'],body['rfq_id'],body['quote_id'],requester,str(body['nonce']),created,received,json.dumps(signature,sort_keys=True)))
-                inst=db.execute('SELECT * FROM instruments WHERE instrument_id=?',(rfq['instrument_id'],)).fetchone(); trade_id=rid('trade3'); amount=int(rfq['quantity'])*int(quote['price'])
-                db.execute('INSERT INTO trades VALUES(?,?,?,?,?,?,?,?,?,?,?,?)',(trade_id,rfq['venue_id'],rfq['instrument_id'],None,None,buyer,seller,int(rfq['quantity']),int(quote['price']),'RFQ','EXECUTED',now_ms()))
+                inst=db.execute('SELECT * FROM instruments WHERE instrument_id=?',(rfq['instrument_id'],)).fetchone()
+                venue=db.execute("SELECT * FROM venues WHERE venue_id=? AND status='ACTIVE'",(rfq['venue_id'],)).fetchone()
+                if not inst or not venue: raise KeyError('RFQ instrument/venue missing')
+                trade_id=rid('trade3'); amount=int(rfq['quantity'])*int(quote['price']); trade_created=now_ms()
+                db.execute('INSERT INTO trades VALUES(?,?,?,?,?,?,?,?,?,?,?,?)',(trade_id,rfq['venue_id'],rfq['instrument_id'],None,None,buyer,seller,int(rfq['quantity']),int(quote['price']),'RFQ','EXECUTED',trade_created))
                 db.execute('INSERT INTO clearing VALUES(?,?,?,?,?,?,?,?)',(trade_id,buyer,seller,amount,inst['settlement_currency'],'PENDING',None,0))
                 self._bind_trade_revenue(db,trade_id,rfq['instrument_id'])
+                source_created=now_ms()
+                source_body={'schema':'entity-eep-rfq-execution-source-v1','trade_id':trade_id,'venue_id':rfq['venue_id'],'instrument_id':rfq['instrument_id'],
+                             'rfq_id':body['rfq_id'],'quote_id':body['quote_id'],'acceptance_id':body['acceptance_id'],
+                             'requester':requester,'provider':quote['provider'],'buyer':buyer,'seller':seller,
+                             'quantity':int(rfq['quantity']),'price':int(quote['price']),'venue_operator':venue['operator'],'created_at_ms':source_created}
+                source_sig=self.identity.sign(venue['operator'],source_body)
+                db.execute('INSERT INTO rfq_trade_sources VALUES(?,?,?,?,?,?,?)',(trade_id,body['rfq_id'],body['quote_id'],body['acceptance_id'],venue['operator'],source_created,json.dumps(source_sig,sort_keys=True)))
                 db.execute("UPDATE rfqs SET status='ACCEPTED' WHERE rfq_id=?",(body['rfq_id'],)); db.execute("UPDATE quotes SET status='ACCEPTED' WHERE quote_id=?",(body['quote_id'],))
         except sqlite3.IntegrityError as exc: raise ValueError('duplicate/replayed RFQ acceptance') from exc
         return dict(body,status='EXECUTED',trade_id=trade_id,execution_model='RFQ',received_at_ms=received,signature=signature)
@@ -596,7 +607,7 @@ def surveillance_alerts(self,venue_id):
         return [{**dict(r),'evidence':json.loads(r['evidence_json'])} for r in rows]
     def status(self):
         with self._db() as db:
-            tables=('venues','instruments','listings','orders','order_cancellations','trades','clearing','payment_attestations','settlement_verifiers','entitlements','usage','surveillance','rfqs','quotes','rfq_acceptances','revenue_rule_sets','trade_revenue_bindings')
+            tables=('venues','instruments','listings','orders','order_cancellations','trades','clearing','payment_attestations','settlement_verifiers','entitlements','usage','surveillance','rfqs','quotes','rfq_acceptances','rfq_trade_sources','revenue_rule_sets','trade_revenue_bindings')
             counts={name:int(db.execute(f'SELECT COUNT(*) FROM {name}').fetchone()[0]) for name in tables}
         return {'schema':'entity-eep-status-v1','profile':'ENTITY_EXCHANGE_PROTOCOL','version':'3.0.0',
                 'rights_are_traded_not_bytes':True,'venue_neutral':True,'payment_versus_right_transfer':True,
diff --git a/src/33_Economic_Participation/economic_participation.py b/src/33_Economic_Participation/economic_participation.py
index 4697cf89..d826c9dd 100644
--- a/src/33_Economic_Participation/economic_participation.py
+++ b/src/33_Economic_Participation/economic_participation.py
@@ -292,6 +292,57 @@ def _verify_eep_sell_order(self,order_row):
             raise PermissionError('EEP sell order signature invalid')
         return True
 
+    def _verify_eep_rfq_trade_source(self,ex,trade):
+        source=ex.execute('SELECT * FROM rfq_trade_sources WHERE trade_id=?',(trade['trade_id'],)).fetchone()
+        if not source:
+            raise PermissionError('settled RFQ trade source binding missing')
+        rfq=ex.execute('SELECT * FROM rfqs WHERE rfq_id=?',(source['rfq_id'],)).fetchone()
+        quote=ex.execute('SELECT * FROM quotes WHERE quote_id=?',(source['quote_id'],)).fetchone()
+        acceptance=ex.execute('SELECT * FROM rfq_acceptances WHERE acceptance_id=?',(source['acceptance_id'],)).fetchone()
+        venue=ex.execute('SELECT * FROM venues WHERE venue_id=?',(trade['venue_id'],)).fetchone()
+        if not rfq or not quote or not acceptance or not venue:
+            raise PermissionError('RFQ signed source records missing')
+        if str(trade['execution_model']).upper()!='RFQ':
+            raise PermissionError('RFQ source binding attached to non-RFQ trade')
+        if source['venue_operator']!=venue['operator']:
+            raise PermissionError('RFQ source venue operator mismatch')
+        if rfq['venue_id']!=trade['venue_id'] or rfq['instrument_id']!=trade['instrument_id']:
+            raise PermissionError('RFQ source venue/instrument mismatch')
+        if quote['rfq_id']!=rfq['rfq_id'] or acceptance['rfq_id']!=rfq['rfq_id'] or acceptance['quote_id']!=quote['quote_id']:
+            raise PermissionError('RFQ source linkage mismatch')
+        if acceptance['requester']!=rfq['requester'] or rfq['status']!='ACCEPTED' or quote['status']!='ACCEPTED':
+            raise PermissionError('RFQ source acceptance mismatch')
+        buyer=rfq['requester'] if rfq['side']=='BUY' else quote['provider']
+        seller=quote['provider'] if rfq['side']=='BUY' else rfq['requester']
+        if buyer!=trade['buyer'] or seller!=trade['seller'] or int(rfq['quantity'])!=int(trade['quantity']) or int(quote['price'])!=int(trade['price']):
+            raise PermissionError('RFQ source economics/participants mismatch')
+        rfq_body={'schema':'entity-eep-rfq-v1','rfq_id':rfq['rfq_id'],'venue_id':rfq['venue_id'],'instrument_id':rfq['instrument_id'],
+                  'requester':rfq['requester'],'side':rfq['side'],'quantity':int(rfq['quantity']),'expires_at_ms':int(rfq['expires_at_ms']),
+                  'nonce':rfq['nonce'],'created_at_ms':int(rfq['created_at_ms'])}
+        quote_body={'schema':'entity-eep-rfq-quote-v1','quote_id':quote['quote_id'],'rfq_id':quote['rfq_id'],'provider':quote['provider'],
+                    'price':int(quote['price']),'expires_at_ms':int(quote['expires_at_ms']),'nonce':quote['nonce'],'created_at_ms':int(quote['created_at_ms'])}
+        acceptance_body={'schema':'entity-eep-rfq-acceptance-v1','acceptance_id':acceptance['acceptance_id'],'rfq_id':acceptance['rfq_id'],
+                         'quote_id':acceptance['quote_id'],'requester':acceptance['requester'],'nonce':acceptance['nonce'],
+                         'created_at_ms':int(acceptance['created_at_ms'])}
+        signed=((rfq['requester'],rfq_body,rfq['signature_json'],'RFQ request'),
+                (quote['provider'],quote_body,quote['signature_json'],'RFQ quote'),
+                (acceptance['requester'],acceptance_body,acceptance['signature_json'],'RFQ acceptance'))
+        for entity_id,body,signature_json,label in signed:
+            manifest=self.identity.load_manifest(entity_id)
+            if not signature_json or not self.identity.verify_signature(manifest,body,json.loads(signature_json)):
+                raise PermissionError(f'{label} signature invalid')
+        source_body={'schema':'entity-eep-rfq-execution-source-v1','trade_id':trade['trade_id'],'venue_id':trade['venue_id'],'instrument_id':trade['instrument_id'],
+                     'rfq_id':rfq['rfq_id'],'quote_id':quote['quote_id'],'acceptance_id':acceptance['acceptance_id'],
+                     'requester':rfq['requester'],'provider':quote['provider'],'buyer':buyer,'seller':seller,
+                     'quantity':int(trade['quantity']),'price':int(trade['price']),'venue_operator':venue['operator'],'created_at_ms':int(source['created_at_ms'])}
+        venue_manifest=self.identity.load_manifest(venue['operator'])
+        if not self.identity.verify_signature(venue_manifest,source_body,json.loads(source['signature_json'])):
+            raise PermissionError('RFQ execution source signature invalid')
+        return {'execution_model':'RFQ','rfq_id':rfq['rfq_id'],'quote_id':quote['quote_id'],'acceptance_id':acceptance['acceptance_id'],
+                'rfq_request_signature_verified':True,'rfq_quote_signature_verified':True,
+                'rfq_acceptance_signature_verified':True,'rfq_execution_source_signature_verified':True,
+                'seller_authority_signature_verified':True,'seller_authority_path':'SIGNED_RFQ_SOURCE'}
+
     def _obligation(self,event,payer,recipient,amount,currency,basis,bps):
         amount=max(0,int(amount)); bps=int(bps)
         if amount==0: return None
@@ -344,9 +395,16 @@ def capture_settled_eep_trade(self,exchange,trade_id):
             clearing=ex.execute("SELECT * FROM clearing WHERE trade_id=? AND status='SETTLED'",(str(trade_id),)).fetchone()
             if not trade or not clearing: raise KeyError('settled EEP trade required')
             inst=ex.execute('SELECT * FROM instruments WHERE instrument_id=?',(trade['instrument_id'],)).fetchone()
-            sell_order=ex.execute('SELECT * FROM orders WHERE order_id=?',(trade['sell_order_id'],)).fetchone()
-        if not sell_order or sell_order['participant']!=trade['seller']: raise PermissionError('settled trade/sell order mismatch')
-        self._verify_eep_sell_order(sell_order)
+            if str(trade['execution_model']).upper()=='RFQ':
+                authority_details=self._verify_eep_rfq_trade_source(ex,trade); sell_order=None
+            else:
+                sell_order=ex.execute('SELECT * FROM orders WHERE order_id=?',(trade['sell_order_id'],)).fetchone(); authority_details=None
+        if authority_details is None:
+            if not sell_order or sell_order['participant']!=trade['seller']: raise PermissionError('settled trade/sell order mismatch')
+            self._verify_eep_sell_order(sell_order)
+            authority_details={'execution_model':str(trade['execution_model']).upper(),'sell_order_signature_verified':True,
+                               'sell_order_id':sell_order['order_id'],'seller_authority_signature_verified':True,
+                               'seller_authority_path':'SIGNED_SELL_ORDER'}
         policy=self._active_policy(trade['instrument_id'],trade['created_at_ms']); treasury=self._treasury(policy['treasury_id'])
         if inst['issuer']!=policy['originator_entity_id']: raise PermissionError('instrument issuer/policy originator mismatch')
         is_primary=trade['seller']==inst['issuer']; event_type='PRIMARY_RIGHTS_SALE' if is_primary else 'SECONDARY_RIGHTS_SALE'
@@ -355,7 +413,7 @@ def capture_settled_eep_trade(self,exchange,trade_id):
             event_type,policy,treasury,policy['originator_entity_id'],trade_id,gross,clearing['currency'],{
                 'buyer':trade['buyer'],'seller':trade['seller'],'quantity':int(trade['quantity']),'price':int(trade['price']),
                 'source_payment_ref':clearing['payment_ref'],'source_external_verified':bool(clearing['external_verified']),
-                'sell_order_signature_verified':True,'sell_order_id':sell_order['order_id'],
+                **authority_details,
                 'participation_is_allocation_within_gross':True,'atomic_event_obligation':True},
             trade['seller'],treasury['treasury_entity_id'],gross*bps//10000,
             'PRIMARY_TREASURY_ALLOCATION' if is_primary else 'SECONDARY_ORIGINATOR_ROYALTY',bps,
diff --git a/src/34_Market_Recovery/market_recovery.py b/src/34_Market_Recovery/market_recovery.py
index e1e36b6f..11a510f8 100644
--- a/src/34_Market_Recovery/market_recovery.py
+++ b/src/34_Market_Recovery/market_recovery.py
@@ -17,7 +17,7 @@
     "revenue_rule_sets", "trade_revenue_bindings", "surveillance", "rfqs", "quotes", "rfq_acceptances",
     "order_cancellations", "settlement_verifiers", "payment_attestations",
 )
-EEP_OPTIONAL = ("revenue_events",)
+EEP_OPTIONAL = ("revenue_events", "rfq_trade_sources")
 EOPP_REQUIRED = (
     "treasuries", "participation_policies", "reserve_allocations",
     "economic_events", "obligations", "position_snapshots", "settlement_verifiers",
diff --git a/tests/test_v3_economic_participation.py b/tests/test_v3_economic_participation.py
index 0b3ea521..a32ea98e 100644
--- a/tests/test_v3_economic_participation.py
+++ b/tests/test_v3_economic_participation.py
@@ -35,7 +35,7 @@ def setUp(self):
         self.profile.authorize_settlement_verifier(self.treasury['treasury_id'],self.originator,self.verifier)
         self.policy=self.profile.define_participation(self.originator,self.treasury['treasury_id'],self.instrument['instrument_id'],1000,200,'CAD',primary_treasury_bps=2500,secondary_royalty_bps=150,derivative_participation_bps=100,terms={'raw_redistribution':'PROHIBITED'})
         self.profile.allocate_eep_reserve(self.exchange,self.policy['policy_id'])
-        self.venue=self.exchange.create_venue(self.originator,'Rights Exchange','CA',['ORDER_BOOK'],hashlib.sha256(b'venue policy').hexdigest())
+        self.venue=self.exchange.create_venue(self.originator,'Rights Exchange','CA',['ORDER_BOOK','RFQ'],hashlib.sha256(b'venue policy').hexdigest())
         disclosure=hashlib.sha256(b'disclosure').hexdigest()
         self.exchange.publish_disclosure(self.venue['venue_id'],self.instrument['instrument_id'],self.originator,'OFFERING',disclosure)
         self.exchange.list_instrument(self.venue['venue_id'],self.instrument['instrument_id'],self.originator,1,1,disclosure)
@@ -50,6 +50,18 @@ def _trade(self,seller,buyer,quantity,price,nonce):
         self.assertEqual(settled['status'],'SETTLED')
         return trades[0]
 
+    def _rfq_trade(self,seller,buyer,quantity,price,nonce,side='BUY'):
+        expiry=econ_mod.now_ms()+60_000
+        requester=buyer if side=='BUY' else seller
+        provider=seller if side=='BUY' else buyer
+        rfq=self.exchange.create_rfq(self.venue['venue_id'],self.instrument['instrument_id'],requester,side,quantity,expires_at_ms=expiry,nonce=nonce+'-rfq')
+        quote=self.exchange.quote_rfq(rfq['rfq_id'],provider,price,expires_at_ms=expiry,nonce=nonce+'-quote')
+        execution=self.exchange.accept_quote(rfq['rfq_id'],quote['quote_id'],requester,nonce=nonce+'-accept')
+        self.assertEqual(execution['execution_model'],'RFQ')
+        settled=self.exchange.settle_trade(execution['trade_id'],'payment:'+nonce,external_verified=False)
+        self.assertEqual(settled['status'],'SETTLED')
+        return execution,rfq,quote
+
     def test_btg_deployment_uses_verified_supplied_ids_not_hardcoded_privilege(self):
         profile=econ_mod.EconomicParticipationProfile(self.tmp.name+'-btg',self.identity)
         record=btg_mod.provision_btg_treasury(profile,self.originator,self.treasury_entity,{'policy':'BTG economic participation','version':1})
@@ -106,6 +118,64 @@ def guarded_sign(entity_id,payload):
         with self.assertRaises(ValueError):
             self.profile.capture_settled_eep_trade(self.exchange,secondary['trade_id'])
 
+    def test_rfq_primary_sale_captures_signed_execution_source(self):
+        execution,rfq,quote=self._rfq_trade(self.originator,self.buyer1,10,100,'rfq-primary','BUY')
+        captured=self.profile.capture_settled_eep_trade(self.exchange,execution['trade_id'])
+        self.assertEqual(captured['trade_class'],'PRIMARY')
+        self.assertEqual(captured['gross_amount_units'],1000)
+        self.assertEqual(captured['obligation']['amount_units'],250)
+        details=captured['event']['details']
+        self.assertEqual(details['execution_model'],'RFQ')
+        self.assertEqual(details['rfq_id'],rfq['rfq_id'])
+        self.assertEqual(details['quote_id'],quote['quote_id'])
+        self.assertTrue(details['rfq_request_signature_verified'])
+        self.assertTrue(details['rfq_quote_signature_verified'])
+        self.assertTrue(details['rfq_acceptance_signature_verified'])
+        self.assertTrue(details['rfq_execution_source_signature_verified'])
+        self.assertEqual(details['seller_authority_path'],'SIGNED_RFQ_SOURCE')
+        with self.exchange._db() as db:
+            source=db.execute('SELECT * FROM rfq_trade_sources WHERE trade_id=?',(execution['trade_id'],)).fetchone()
+        self.assertIsNotNone(source)
+
+    def test_rfq_secondary_sell_request_captures_without_seller_private_key(self):
+        seed=self._trade(self.originator,self.buyer1,20,100,'rfq-secondary-seed')
+        self.profile.capture_settled_eep_trade(self.exchange,seed['trade_id'])
+        execution,rfq,quote=self._rfq_trade(self.buyer1,self.buyer2,5,120,'rfq-secondary','SELL')
+        original_sign=self.identity.sign
+        def guarded_sign(entity_id,payload):
+            if entity_id==self.buyer1:
+                raise AssertionError('RFQ secondary seller private key must not be used during EOPP capture')
+            return original_sign(entity_id,payload)
+        self.identity.sign=guarded_sign
+        try:
+            captured=self.profile.capture_settled_eep_trade(self.exchange,execution['trade_id'])
+        finally:
+            self.identity.sign=original_sign
+        self.assertEqual(captured['trade_class'],'SECONDARY')
+        self.assertEqual(captured['gross_amount_units'],600)
+        self.assertEqual(captured['obligation']['amount_units'],9)
+        self.assertEqual(captured['event']['details']['seller_authority_path'],'SIGNED_RFQ_SOURCE')
+        self.assertEqual(captured['event']['details']['rfq_id'],rfq['rfq_id'])
+        self.assertEqual(captured['event']['details']['quote_id'],quote['quote_id'])
+
+    def test_rfq_capture_fails_closed_without_source_binding(self):
+        execution,_,_=self._rfq_trade(self.originator,self.buyer1,2,100,'rfq-missing-source','BUY')
+        with self.exchange._db() as db:
+            db.execute('DELETE FROM rfq_trade_sources WHERE trade_id=?',(execution['trade_id'],))
+        with self.assertRaises(PermissionError):
+            self.profile.capture_settled_eep_trade(self.exchange,execution['trade_id'])
+        with self.profile._db() as db:
+            self.assertEqual(db.execute('SELECT COUNT(*) FROM economic_events WHERE subject_ref=?',(execution['trade_id'],)).fetchone()[0],0)
+
+    def test_rfq_capture_fails_closed_on_tampered_quote_signature(self):
+        execution,_,quote=self._rfq_trade(self.originator,self.buyer1,2,100,'rfq-tamper-source','BUY')
+        with self.exchange._db() as db:
+            db.execute("UPDATE quotes SET signature_json='{}' WHERE quote_id=?",(quote['quote_id'],))
+        with self.assertRaises(PermissionError):
+            self.profile.capture_settled_eep_trade(self.exchange,execution['trade_id'])
+        with self.profile._db() as db:
+            self.assertEqual(db.execute('SELECT COUNT(*) FROM economic_events WHERE subject_ref=?',(execution['trade_id'],)).fetchone()[0],0)
+
     def test_derivative_participation_and_service_revenue(self):
         derivative=self.profile.record_derivative_revenue(self.policy['policy_id'],self.buyer1,'derivative:model-x',100000,'CAD',hashlib.sha256(b'revenue evidence').hexdigest())
         self.assertEqual(derivative['obligation']['amount_units'],1000)