# FINANCIER / FINCR — Robinhood-native accepted-agent payout settlement

Research date: 2026-10-19. Source pin: `imd-financier/financier-open` @ `153f1ebeca4951013168609adcc6b0a17c32dc54`.
Scope: the missing authenticated, COMPLETE accepted-agent → payout-wallet settlement interface for the 20% agent share of FINCR mining on Robinhood Chain (4663).

## 1. Verdict

**REQUIRES IMD SUPPORT** (with a disclosed, bounded trust-based MVP fallback available today).

- No existing official IMD mechanism on Robinhood Chain 4663 produces an authenticated and COMPLETE manifest of `(agentId, acceptedSubmission, payoutWallet)` for a `job.open` job.
- What IMD authenticates on Robinhood today: payment, request ID, exact body, payer, and a single completion callback `onResult(requestId, resultHash, uri)` written by the Intake writer. The result hash binds a result document; it does not bind, enumerate, or sign the accepted agent set or any payout wallet.
- What IMD authenticates elsewhere: per-job work receipts (`WorkRegistry.recordWork`) and per-agent acceptance signals (ERC-8004 `ReputationRegistry.NewFeedback`) exist **only on Ethereum mainnet (chain 1)**, written by the WorkRegistry writer `0x5da3…6d44`. The docs state explicitly that receipts and reviews are written "on Ethereum only" and the Robinhood contract table lists no WorkRegistry or ERC-8004 registry.
- Even the Ethereum receipt carries no payout wallet, no owner signature, and no "this is the complete set" assertion (completeness is implicit in the single `recordWork` call per job, which the writer could in principle amend by chaining `previousHash`).
- The repository's `AttestedAgentRounds` already models exactly the missing authority (an authority-attested complete set + ownership evidence) but `FounderFundedMining` wires that authority slot to `RobinhoodJobController`, which has no `finalize` path. Therefore the deployed design quarantines 100% of agent emissions by construction unless a settlement authority is introduced before deployment.

The smallest missing piece is a **Robinhood-native, IMD-signed "job acceptance manifest"**: an EIP-712 statement over `(chainId 4663, intake requestId, jobId, final work-record documentHash, ordered list of (agentId, submissionHash, payoutWallet), revision, expiry)` signed by an IMD authority key that FINANCIER can pin. The responsible authority is the IMD operator (the same party that runs the Intake writer `0x3d3c…25cb`, the WorkRegistry writer `0x5da3…6d44` and the oracle signer `0x5598…2982`). No such endpoint or signature exists today; the oracle's existing EIP-712 `OracleAttestation` is the closest shape, but it is restricted to chain-evidence recipes and cannot today attest "the accepted agents of job X" (see §3).

## 2. Evidence table (primary sources)

| # | Claim | Source | Status |
|---|-------|--------|--------|
| E1 | Intake v2 on Robinhood 4663 is `0xa43e6f75ee006411f79ac1c84120606c2330de82`; `job.open@job-1` costs 0.5 IMD; `onResult(bytes32 requestId, bytes32 resultHash, string uri)`; only the Intake writer `0x3d3c0df7c1a17d384545e9d7c8228897bd9625cb` calls `complete`; "no refunds" | https://imd.fun/docs/ (fetched 2026-10-19) | Verified (doc) |
| E2 | Robinhood runtime codehash of Intake v2 `0xd96f270d…b5e8` and IMD `0xa9a0e893…93e2` pinned and rehearsed on a fork | `src/FinancierMiningWithSettlement.sol:16-21`, `verification/fork/RobinhoodIntake.t.sol:19-29`, `test/fixtures/task16/*.hex` | Verified (repo, eth_getCode observation) |
| E3 | Genuine successful Robinhood job (oracle action, Intake v1 `0x1397…ea56`): tx `0x5933a9945475b878d9c6b64ab1a9e873e958160333f8b7cb396e197208afc179`, block `0x506189c`, chainId `0x1237`=4663, from Intake writer `0x3d3c…25cb`, callback into consumer `0x3c81384aa1ca064316576a214e2fb30969992772` with signed EIP-712 `OracleAttestation` (signer `0x5598aa9146215bc13eb26f2c692ad1461fd32982`, panel 7, quorum 5, agreed 5) | `test/fixtures/task6/pinky-callback.json`; https://api.imd.fun/oracle/requests/dbcac6c2-6328-47a9-8e07-4c7b55f78e45/attestation (fetched 2026-10-19, identical) | Verified (chain record + live API) |
| E4 | Genuine successful multi-agent `job.open` job `3d7ff049-1447-4076-8e84-635c42acf5e0` (5 accepted agents 50962, 51284, 51028, 51073, 51060): receipt written on **Ethereum**, tx `0x952500a5c41cae67745dd5ea162855c6060900e529268e88c3cebee07bef1c21`, block 26,189,670 (2026-10-14 08:53:47 UTC), `WorkRegistry 0xb6d0a187b050fa5bb0b87033a203f37becf4a775`, function `recordWork(bytes16 jobId, bytes32 previousHash, bytes32 documentHash, string uri, tuple[] signals)` selector `0x765b59a5`, from `0x5da3054201bc7e241875ac68173e49c269f76d44`; 5 `NewFeedback` events on ERC-8004 ReputationRegistry `0x8004baa17c55a88189ae136b182e5fda19de9b63` + 1 `WorkRecorded` | `test/fixtures/real-chain/work-receipt.json`; https://etherscan.io/tx/0x952500a5… ; https://explorer.imd.fun/jobs/3d7ff049-1447-4076-8e84-635c42acf5e0 | Verified (chain record + explorer) |
| E5 | The work record document (`schema: identitymd-work-v1`) lists per-node `acceptedSubmissionHash`, `signals[{agentId, submissionHash, value:1, tag2:"acceptance-v2"}]`, `verification[{status:"accepted", evaluation:"structural"}]` and identity registry `0x8004a169fb4a3325136eb29fa0ceb6d2e539a432` on chainId 1. It contains **no wallet, owner, signer or signature field** | https://api.imd.fun/work-records/6e6570b4b0e37c889ed9e12b4656dacfbc56275fd75610bf2655167045ca5146.json (fetched 2026-10-19); `test/fixtures/imd-work/work-record.json` | Verified |
| E6 | Review document per agent (`metric:"acceptance"`, `value:1`, `qualityScore:null`, `revisions:0`) also has no wallet/signature | https://api.imd.fun/review-documents/572b9021afa68a6aea1019720df7c72ec90aac84bec8aabda04d88af76d4fbae.json ; `test/fixtures/imd-work/review.json` | Verified |
| E7 | Docs: "Receipts: the WorkRegistry writer `0x5da3…6d44` writes receipts and reviews, on Ethereum only." Robinhood table lists only Intake and IntakeDelivery `0xce0e6a670aa75e161d02aca3c7f00b94ca428ccb`; "No WorkRegistry or ERC-8004 entries are listed." Agent IDs "come from the ERC-8004 IdentityRegistry, which IMD does not deploy." | https://imd.fun/docs/ (second half) | Verified (doc) |
| E8 | Docs: oracle answer types `bool, address, bytes32, uint256, address[], bytes32[]`; questions are "chain-evidence recipes" (`log-sum`, `log-count`, `log-rank`, `call-compare`, `v4-volume-rank`, `univ4-spot`); "the deployer reruns the agreed recipe at the pinned blocks before it signs"; `not_answerable` 422 otherwise | https://imd.fun/docs/ | Verified (doc) |
| E9 | Launch reward snapshots (`rewardSnapshot`, `claims=1 → {root, leaves:[{wallet, amount, proof}]}`) exist only for token launches via the factory distributor; the Robinhood factory is `0x9c9d2fcb75c2c132c0ac0c42df3819a42347265e` (launch 1727 fixture) | https://imd.fun/docs/ ; `script/readiness_rpc.py:14-25`; `test/fixtures/real-chain/launch-1727-calldata.json` | Verified; **not applicable** to per-job agent payout (different authority and leaf schema) |
| E10 | Repo: completion never authorizes payout; empty-artifact "success" regression; controller has no finalize | `src/FounderFundedMining.sol:92-102`, `src/RobinhoodJobController.sol:14-16`, `test/Task27BGenesis.t.sol:162-182` | Verified (code) |

Not verifiable in this run: the Robinhood block explorer (`explorer.mainnet.chain.robinhood.com`) refused TLS from this sandbox, so Robinhood tx `0xdcb2e5a4…bf1b5` (listed in `script/readiness_rpc.py:33`) was not re-fetched; E3 relies on the repo's RPC capture, whose block/chain fields are internally consistent.

## 3. What IMD authenticates today vs. what is missing

Verified facts (F), inferences (I), assumptions (A), unresolved (U) are tagged.

**Authenticated on Robinhood 4663 today (F):**
1. Payment of exactly 0.5 IMD by the vault to payee `0x4e0fa57bde726079356537e2f34d671e9f41adbc` and the returned `requestId` (`Intake.requests(id)` → payer/target/selector/completed) — E1, E2.
2. Exact body bytes (vault stores `keccak256(body)` in `workRequests[requestId]`) — `FinancierMiningWithSettlement.sol:138`.
3. A single completion event per request: `onResult(requestId, resultHash, uri)` or `onFailure(requestId, status, reason, …)`, callable only by the Intake writer — E1, E10.
4. Oracle attestations as EIP-712 signatures by `0x5598…2982` verifiable in a consumer contract on 4663 — E3.

**Authenticated only on Ethereum (F):** per-job `recordWork` receipt chaining `previousHash → documentHash`, and per-agent `NewFeedback(agentId, …)` acceptance signals — E4, E5, E7.

**Not authenticated anywhere (F):**
- Payout wallet for an `agentId`. ERC-8004 `ownerOf(agentId)` on Ethereum identifies a controller, not a Robinhood payout wallet, and no owner signature is included in any IMD document (E5, E6).
- Completeness assertion ("these N and no others were accepted for this job"). The work record is implicitly complete, but there is no field or signature stating finality/revision (`revisions:0` per review, `previousHash` chain per job allows later records) (I from E4, E5).
- Any Robinhood-native commitment to the agent set. `resultHash` in `onResult` is `keccak256` of the result document at the URI (E1). Whether that document embeds the work-record `documentHash` or the signals is **U** (the `/jobs/:id/result` schema is not published; the FINANCIER job has not been run).

**The smallest missing authority (I):** an IMD-operator-signed, Robinhood-domain-separated *Acceptance Manifest* per Intake request. Responsible party: IMD operator (Intake writer / WorkRegistry writer keys are already operator-controlled; the oracle signer already signs EIP-712 for 4663). Nobody else can issue it without inventing authorization: the founder, the financier or FINANCIER's own controller are all parties with an interest in the payout and cannot attest completeness.

**Why the oracle cannot substitute today (F+I):** the oracle only answers chain-evidence recipes over logs/calls (E8). A `log-rank`/`bytes32[]` question over Ethereum `NewFeedback` events filtered to the FINANCIER job could in principle return the accepted `agentId` list cross-chain, but (a) it introduces the Ethereum dependency the brief asks to avoid, (b) `NewFeedback` carries no wallet, (c) `questionHash` binds the job ID only if IMD's recipe grammar supports an indexed-topic filter on `feedbackHash`/job, which the docs do not state (**U**), and (d) the oracle signs with the same operator key, so it is not a stronger authority than a direct manifest, only a more awkward one.

## 4. Proposed official interface (requires IMD support)

EIP-712 domain: `{name:"IdentityMD Acceptance", version:"1", chainId:4663, verifyingContract:<FINANCIER AttestedAgentRounds>}` (same pattern as the oracle: the consumer sets the verifying contract — E3).

```solidity
struct AcceptedAgent {
    uint256 agentId;        // ERC-8004 id on identity chain (today: chainId 1, 0x8004a169…)
    bytes32 submissionHash; // SHA-256 accepted submission (work record / NewFeedback)
    address payout;         // wallet the agent's controller authorized for chain 4663
    bytes32 ownerAuthHash;  // keccak of controller's signed payout authorization (IMD-verified)
}
struct AcceptanceManifest {
    bytes32 requestId;      // Intake requestId on 4663 (binds payment + body)
    bytes16 jobId;          // backend job UUID
    bytes32 bodyHash;       // keccak256(body) — must equal vault.workRequests[requestId].bodyHash
    bytes32 documentHash;   // final work-record documentHash (chain-1 receipt)
    bytes32 agentsHash;     // keccak256(abi.encode(AcceptedAgent[]))
    uint32  revision;       // monotonically increasing; final when `closed`
    bool    closed;         // IMD asserts no further records will chain for jobId
    uint64  issuedAt;
    uint64  expiresAt;
}
// typehash: keccak256("AcceptanceManifest(bytes32 requestId,bytes16 jobId,bytes32 bodyHash,bytes32 documentHash,bytes32 agentsHash,uint32 revision,bool closed,uint64 issuedAt,uint64 expiresAt)")
```

Delivery options (either is acceptable; the first is Robinhood-native and needs no new contract from IMD):
- `GET /jobs/:id/acceptance-manifest` returning typed data + signature, consumed by a new `finalizeWithManifest` on FINANCIER (below). Finality: `closed == true` and `expiresAt > now`. Revocation: a later manifest with higher `revision` and `closed` supersedes only if not yet finalized; after finalization the round is immutable. Replay: `(requestId)` is single-use via `requestRoundPlusOne` and the round is one-shot.
- Alternatively IMD delivers the manifest through the existing `IntakeDelivery` contract on 4663 (`0xce0e…ccb`) as a second callback. Not documented for jobs today (**U**).

## 5. Minimal pre-deployment contract changes (pseudocode)

The immutable `FounderFundedMining` must change *before* deployment; nothing here is an upgrade.

1. **Replace the authority slot** so settlement is a distinct, pinned signer instead of `RobinhoodJobController` (which keeps scope/dispatch only):

```solidity
// AttestedAgentRounds (new constructor arg)
address public immutable manifestSigner;   // IMD operator key, pinned at deploy (placeholder until IMD publishes it)
bytes32 public immutable DOMAIN_SEPARATOR; // EIP-712, chainId 4663, verifyingContract = address(this)

function finalizeWithManifest(
    uint256 id,
    AcceptanceManifest calldata m,
    AcceptedAgent[] calldata agents,
    bytes calldata sig
) external nonReentrant {
    IAgentWorkVerifier.Context memory c = context(id);
    require(!rounds[id].finalized && scopes[id].committed, "state");
    require(block.timestamp >= c.end && block.timestamp <= c.deadline, "window");
    require(m.closed && m.expiresAt >= block.timestamp && m.issuedAt < c.deadline, "manifest");
    require(requestRoundPlusOne[m.requestId] == id + 1, "unbound request"); // set by bindJob
    (uint256 r, bytes32 body,) = vault.workRequests(m.requestId);
    require(r == id + 1 && body == m.bodyHash, "body");
    (, , , bool completed) = IIMDIntakeViews(WORK_INTAKE).requests(m.requestId);
    require(completed && vault.completions(m.requestId).status == 0, "not completed");
    require(m.agentsHash == keccak256(abi.encode(agents)) && agents.length <= MAX_AGENTS, "agents");
    require(ECDSA.recover(_hashTypedData(m), sig) == manifestSigner, "sig");
    _dedupeAndCredit(id, agents);          // identity = (sourceChain, registry, agentId); payout unique; ownerAuthHash unique
    emit RoundFinalized(...);
}
```

2. **Keep bounds intact:** `_allocate` already pays `budget / n` per distinct agent from `vault.agentAllocation(start,end)`, so FINCR agent payouts stay within the 20% stream and financier `claimFincr` is untouched (`FinancierMining.sol:202-206, 293-297`).
3. **Dedupe policy (approved identity policy):** one share per distinct `(chainId, identityRegistry, agentId)`, reject duplicate `payout`, duplicate `submissionHash`, duplicate `ownerAuthHash`; reject `payout == vault/rounds/intake`. Agents with `value != 1` or missing `verification.status == "accepted"` are not in the manifest by definition.
4. **Signer rotation:** none (immutable). If IMD rotates keys, unsettled rounds expire to quarantine as today (`expire`). Disclose this.
5. **No Ethereum call path** is introduced; the Ethereum receipt is referenced only by `documentHash` inside the signed manifest.

Until IMD publishes `manifestSigner`, the constructor cannot be given a real value. Do **not** deploy with a stand-in.

## 6. End-to-end sequence (target design)

1. Financier wins the Dutch auction; `RobinhoodJobController.prepareRound(r)` precommits the 3 fixed body hashes (`precommitRound`) before round `r` opens.
2. Financier calls `jobs.commission(r, category)`; the vault pays 0.5 IMD to Intake v2 via `requestWithFailure("job.open@job-1", body, {vault, onResult}, onFailure, IMD, 0.5e18)` and records `workRequests[requestId] = (r+1, bodyHash, now)`.
3. IMD admits the job (backend `admitted`), seats agents, agents submit, verifier accepts submissions (structural or profile-based), job reaches `completed`.
4. Settlement authority (today: nobody; target: IMD-signed manifest) calls `bindJob(r, Admission{requestId, jobId, bodyHash, requestedAt, admittedAt, evidenceHash})` while the window is open.
5. Intake writer calls `vault.onResult(requestId, resultHash, uri)`; the vault records `completions[requestId]` (status 0). This authorizes nothing (E10).
6. IMD writes the Ethereum receipt `recordWork(jobId, prev, documentHash, uri, signals)` (today's behaviour, E4) **and** (new) signs the `AcceptanceManifest` with `closed=true` after the last revision.
7. After `c.end` and before `c.deadline`, anyone submits `finalizeWithManifest(r, m, agents, sig)`; the contract checks request/body/completion linkage, signature, dedupe, then credits `budget/n` to each `payout`.
8. Each agent calls `claim(r)` from its `payout` wallet; `vault.payAgentReward` transfers FINCR, bounded by `agentUnpaid()`.
9. If no valid manifest arrives by `c.deadline`, `expire(r)` quarantines the round's agent budget permanently (no reassignment).

## 7. Adversarial analysis

| Threat | Official-manifest design | Trust-based MVP fallback (§8) |
|---|---|---|
| Omitted agent | Only possible if IMD signs an incomplete `closed` manifest; detectable off-chain by diffing against the Ethereum `NewFeedback` set for `jobId`; agent remedy is social/IMD, not on-chain | Founder/multisig can omit anyone; detectable the same way; no on-chain remedy |
| False inclusion / Sybil | IMD controls seating and acceptance; distinct `agentId` is only as Sybil-resistant as ERC-8004 registration (cheap). Mitigation: equal split caps gain per identity, `MAX_AGENTS=32`, fixed 0.5 IMD job price limits seats | Same plus authority can add fake agents outright; bounded to the round's 20% budget only |
| Malicious wallet substitution | `payout` must be covered by `ownerAuthHash` (controller-signed, IMD-verified); on-chain uniqueness of `payout` and `ownerAuthHash` | Authority asserts wallets; disclosed as trusted |
| Stale / superseded result | `closed`, `revision`, `expiresAt`, `issuedAt < deadline`; round single-shot; `requestRoundPlusOne` one-use | Same contract checks apply if the MVP reuses `finalize` + `Snapshot` fields |
| Replay across chains/contracts | EIP-712 domain pins chainId 4663 and `verifyingContract`; `requestId` is unique per Intake and bound to one round | `settlementCommitment` already includes `block.chainid`, vault, rounds, policyHash, round (`AttestedAgentRounds.sol:274-283`) |
| Callback spoofing | `_record` checks `msg.sender == WORK_INTAKE`, codehash, `requests(id).completed` (E10) | identical |
| Permanently quarantined funds | If IMD never signs (key loss, refusal) or signs after `deadline`, the round's budget is quarantined forever (`expire`). This is by design and must be disclosed; `graceSeconds ≤ 30 days` | Same; plus authority inaction quarantines |
| Empty-success | `onResult` with `keccak("")` passes completion but no manifest → no payout (`test/Task27BGenesis.t.sol:162`) | identical |
| Dishonest authority scope | Cannot touch financier stream, buyback, LP or ops buckets; bounded to `agentAllocation(start,end)` of that round | identical bound |

## 8. Alternatives compared

| Option | Authority | Chain deps | Completeness | Wallet ownership | Status |
|---|---|---|---|---|---|
| A. IMD-signed Acceptance Manifest (§4) | IMD operator key | Robinhood only | Asserted by IMD (`closed`) | IMD-verified controller authorization | **Recommended; needs IMD** |
| B. Oracle `bytes32[]`/`address[]` question over Ethereum `NewFeedback` for the job | Oracle signer `0x5598…` (same operator) | Ethereum evidence, Robinhood signature | Only if recipe can filter by job; **U** | None (no wallets in events) | Not usable today |
| C. Ethereum receipt proof (storage/receipt proof of `WorkRecorded` on chain 1 into 4663) | Ethereum consensus + IMD writer | Requires an Ethereum light client / bridge on Robinhood (none demonstrated) | Implicit, no finality flag | None | Out of scope per brief; heavy |
| D. Launch `rewardSnapshot` Merkle root | IMD launch distributor | Robinhood factory | For launches only, not per-job agents | Wallet leaves exist | Not applicable (E9) |
| E. Trust-based MVP: founder/multisig as `settlementAuthority`, using existing `finalize` with `Snapshot.acceptedSetEvidenceHash = documentHash` and `ownershipEvidenceHash = keccak(owner authorizations)` | FINANCIER multisig | Robinhood only | Trusted, not proven | Trusted, not proven | **Deployable today, must be disclosed as trust-based**; a founder-generated root is not official proof |

Decision for a hackathon MVP: ship **E** with the existing `AttestedAgentRounds.finalize` (already implemented and tested) under a disclosed authority (a 2-of-3 multisig including a non-founder reviewer), with the `policyHash` committing to the published dedupe/wallet policy, and request **A** from IMD in parallel. If IMD delivers A, the next deployment swaps the authority for the signer-verified path in §5.

## 9. Prioritized implementation and validation checklist (MVP)

1. Decide authority for MVP (multisig address is requester-supplied; do not use a placeholder in production). Blocking.
2. Change `FounderFundedMining._nativeConfig` so `c.authority` is that multisig, not the nonce-3 controller; keep `RobinhoodJobController` for `precommitRound`/`dispatchWork` by splitting the authority into `scopeAuthority` and `settlementAuthority` in `AttestedAgentRounds` (two immutables).
3. Add `finalizeWithManifest` (§5) behind an immutable `manifestSigner`; if unknown at deploy, omit the function entirely rather than ship a dead signer.
4. Publish the dedupe/wallet policy document and set `policyHash = keccak256(policy)`.
5. Off-chain tooling: script that builds `Contribution[]` + `OwnerEvidence[]` from `/work-records/:hash.json`, `/jobs/:id/submissions`, and the Ethereum `NewFeedback` logs, and computes `settlementCommitment` for the multisig to sign.
6. Tests to add in `test/`: (a) manifest signature domain/replay rejection, (b) revision supersession, (c) request/body/completion linkage, (d) 32-agent gas bound for `finalizeWithManifest`, (e) `expire` after signer silence, (f) fork rehearsal against Intake v2 runtime with a real-shaped manifest.
7. Run one real 0.5 IMD `job.open` from a throwaway payer (not the vault) to capture the `/jobs/:id/result` schema and determine whether `resultHash` commits to `documentHash` (resolves U1).
8. Ask IMD (written request, with §4 struct) whether they will sign manifests and publish the key; also ask whether oracle recipes can filter `NewFeedback` by job (resolves U2).
9. Disclosure text for README/front-end: agent payouts are trusted-authority attested until IMD support lands; omission has no on-chain remedy; unsettled rounds are quarantined permanently.

## 10. Separation of facts, assumptions, proposals and open dependencies

**Verified facts:** E1–E10 above; the repository design (authority slot = controller without finalize; completion never pays; equal split; 20% bound).

**Inferences:** the IMD operator controls all relevant keys (writer, oracle signer, quote signer are all listed in official docs as operator roles); the Ethereum receipt is implicitly complete but has no finality flag; the oracle cannot today express an acceptance-list question.

**Assumptions:** IMD will continue writing one `recordWork` per completed `job.open`; ERC-8004 identity remains on Ethereum (so `SOURCE_CHAIN=1` in `AttestedAgentRounds` stays correct even for a Robinhood-only payout path); Intake v2 runtime codehash remains stable.

**Proposals (not official):** the `AcceptanceManifest` struct, `finalizeWithManifest`, authority split, and the MVP multisig fallback.

**Unresolved dependencies:**
- U1: content of `/jobs/:id/result` for a FINANCIER job and whether `resultHash` embeds the work-record `documentHash`.
- U2: whether IMD will sign and publish a manifest key, and whether oracle recipes can filter per job.
- U3: a Robinhood-native identity/wallet binding (`POST /agents/bind` and `/seats/owners` are Ethereum-centric).
- U4: Robinhood explorer re-verification of tx `0xdcb2e5a4…` (TLS blocked in this environment).
- U5: the MVP authority address is a requester decision and is not supplied here.