Skip to content

feat(dashpay): redesign the Connections page and add a connection sheet - #1277

Merged
romchornyi merged 267 commits into
developfrom
feat/dashconnect-redesign-connections
Nov 13, 2026
Merged

romchornyi merged 267 commits into
developfrom
feat/dashconnect-redesign-connections

Conversation

@romchornyi

@romchornyi romchornyi commented Oct 31, 2026 •

Copy link
Copy Markdown
Contributor

Rebuilt on #1334 (2026-11-09). This PR is now stacked on #1334 (connection states and disconnect), merged onto this branch without rewriting its history. What differs from the text below:

Issue being fixed or feature implemented

Stacked on #1301 (it was on #1272, which #1301 replaces). First part of the DashConnect redesign (Figma: DashPay / Android, Connections section 40042:59884), following the DashConnect user story's "Connections and details" criteria and the App Connect DIP draft (dashpay/dips#181). Android counterpart: dashpay/dash-wallet#1662.

The redesign is split into five pull requests (stack #1400):

  1. This one: the page, its rows and the connection sheet.
  2. feat(dashpay): the connection sheet shows what an app can spend and do #1399, what the connection sheet says an app can spend and do. Stacked on this one.
  3. feat(dashpay): DashConnect disconnected apps and Reconnect #1289, the disconnected-apps history: the Disconnected tab and Reconnect. Stacked on 2.
  4. feat(dashpay): DashConnect expiry check and Expired tab #1293, the expiry check: the Expired tab. Stacked on 3.
  5. feat(dashpay): redesign the approve sheet with funding limit and expiry pickers #1278, the approve sheet with the funding-limit and expiry pickers. Stacked on 4.

Moved onto #1301 (2026-11-09). #1272 kept a grant record per approval, and this PR read the sheet's details and the disconnect question from those records. #1301 keeps no grant records: the identity on Platform is the source of truth, and the wallet records only an intent (ConnectionIntent) before each identity update. The redesign is rebuilt on that model in one commit (c2c5afe), merged onto this branch without rewriting its history. What changed against the version reviewed so far:

What was done?

Connections page

  • A + in the top bar opens the scanner.
  • Each connected app is one row, with its name and website, and opens its connection sheet.
  • Every row has a Disconnect button: Active, Confirming and Not delivered all may hold keys. The button opens the connection's sheet, which asks there.
  • The status badge goes from the rows; the sheet shows the status.
  • The page follows every save of its rows, by any data source over the same store (UserDefaultsDashConnectStore.didSaveNotification).

Connection sheet

  • It shows:
    • the name, website and status (Active, Confirming or Not delivered);
    • the App ID, username and identity;
    • when the connection was made;
    • the collapsible list of what an app is never given ("will NOT have access to").
  • Its details come from the active identity's intents for the app that are not closed (ConnectionDetails). With a read of the identity, only intents whose keys are live, expired or may still land count. A details read that fails is shown as unavailable and keeps details already shown.
  • What the app can spend and do (its funding limit, each key's remaining budget, when the connection ends, and the "will be able to do" list) moved to feat(dashpay): the connection sheet shows what an app can spend and do #1399, stacked on this PR, where they are built per key from the identity read.
  • Disconnect asks for confirmation once, then runs refactor(dashpay): derive App Connect rows from the identity and a recorded intent #1301's disconnect, and only while the row's status still offers one: a row that turned Refused or Disconnected while the sheet asked does not run it. Its results are shown on the sheet while it is up. The question about unrecorded keys is the exception: it has its own answer on the page.
  • Only the latest read of the sheet's details is shown. A request that arrives while a sheet is open closes the sheet and shows the request once the sheet has gone.

Other

  • The approve sheet's permission lines moved to DashConnectPermissionText. Before approval it says the app "may receive messages encrypted to you": whether it gets a key for them is known only once the approval reads the identity's current key. One visible change: a request with several encryption bindings now shows one "receive messages encrypted to you" line, not one per binding.

Known limits

Screenshots

iPhone, testnet, Yappr connected. These screenshots were taken before the split: the tab control in them moves to PR 2.

Empty Active
IMG_8793 IMG_8794
Connection sheet Granted access Disconnect confirmation
IMG_8797 IMG_8799 IMG_8798

How Has This Been Tested?

  • Unit tests: dashwallet-dashpay scheme, Debug, iOS 27 simulator, against the stack's platform pin. The DashConnect suites, view model tests included, passed: 276 tests, 0 failures. They cover:
    • the page's rows in each status;
    • a row's Disconnect opening its sheet and asking once;
    • a disconnect that cannot run now saying why on the sheet;
    • the question about unrecorded keys waiting for the sheet to go;
    • latest-read-only details, and a failed details read shown as unavailable;
    • another wallet's row closing the sheet;
    • a row removed by another data source leaving the page;
    • a confirmed disconnect not running once the row no longer offers one;
    • an intent without administeredGroupIds still being read.
  • scripts/a11y_audit.py --check: no new findings.
  • The screenshots above are from the version on fix(dashpay): record App Connect v2 grants before their identity update and refuse partial renewals #1272, run on an iPhone against testnet. The version on refactor(dashpay): derive App Connect rows from the identity and a recorded intent #1301 has not run on a device yet.

Breaking Changes

None. An older build ignores the new intent field.

Checklist:

  • I have performed a self-review of my own code
  • I have commented my code, particularly in hard-to-understand areas
  • I have added or updated relevant unit/integration/functional/e2e tests
  • I have made corresponding changes to the documentation

For repository code-owners and collaborators only

  • I have assigned this pull request to a milestone

🤖 Generated with Claude Code

Summary by CodeRabbit

  • New Features

    • Manage connected apps from a dedicated details sheet, with clearer permission, identity, funding, and remaining-budget information.
    • Review funding limits and choose connection budgets and expiry terms when approving app access.
    • See connection states and available actions, including options to disconnect, remove, or reconnect.
    • Scan to connect from the connections screen, including when no connections exist.
  • Improvements

    • Requests that are outdated, from the future, or already answered are handled with clearer status and feedback.
    • Disconnect results explain when access remains active or could not be fully checked.
    • DashConnect interface text has been added across supported languages.

jeanpierreroma and others added 30 commits October 13, 2026 21:04
…w was shown for

A published row now names the wallet and network it was published for,
and disconnect and remove take that scope back. A row picked from a list
that has since moved to another wallet is refused, also when the new
wallet has a row for the same app and the list was already replaced by
the wallet-change notification before the call arrived.

The scope is set where rows are published and cleared before they are
stored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…t at a time per wallet

An approval keeps running after its screen is closed, and a screen opened
again gets a new data source over the same stores. A disconnect started
there could pick the keys to disable before that approval registered one
more, and then mark the new grant as disabled too.

- A process-wide gate lets one approval, key registration or disconnect
  run at a time for a wallet, in arrival order, whichever data source it
  came through. A turn that comes after the active wallet changed does not
  start.
- A disconnect marks disabled, and deletes the responses of, only the
  grants it read before disabling.
- Rows are read from the store for every change instead of from the
  list a data source loaded earlier, so two data sources do not overwrite
  each other's rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…nd show the app contract on the sheet

- A context resolved again after a PIN prompt or a wait at the operation
  gate must match the whole scope of the stores it carries on with, the
  wallet and the network scope: the same wallet on another devnet is
  refused.
- A dash-st: key registration takes its turn for the wallet of the context
  it resolved, and resolves the context again once the turn comes.
- The approval sheet shows the app's contract id in full, selectable: the
  name next to it can be chosen by the code or the contract's owner, and
  the id is what a one-QR key is bound to.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The rules a wallet applies between decoding a v2 request and registering
its keys (Yappr docs/APP_CONNECT_PROFILE.md), as pure functions:

- the grant plan: every binding granted, budget capped at 5 DASH, lifetime
  at 365 days, a 90-day expiry when none is asked, no requested limit
  dropped; stale and future requests refused
- owner consistency: groups and contracts owned by the app's owner, DashPay
  profile the only foreign document type, system contracts never an app or
  a binding target, the app opting in to bound encryption keys
- one auth key per binding at the session-authentication leaf
  hash256(appEphPub || u8 bindingIndex), with deriveConnectKey as it is
- the encryption key (rule 7): resend this wallet's rotation-0 key while it
  is current, register it when there is none, leave the slot out otherwise
- supersession by CONNECTION_ID, and the callback's ac= status

The grant record keeps a v2 grant's other auth keys and its connection id,
and disconnect counts every key a record names.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Moves the tail of the one-QR approval (record check, delete of earlier
responses, publish, settling an unconfirmed publish) into
publishAppConnectResponse so the v2 login can share it. No behaviour
change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A v=2 dash-key: request now reaches the approval sheet instead of being
refused. Building the sheet settles the grant plan and checks it against
Platform (contract and group owners, the identity hint). Approving it
derives one key per binding, settles the app's encryption key, and in one
MASTER-signed identity update adds the new keys and disables this
connection's previous grant. It then records the grant and publishes the
sealed response (one slot per key) to the App Connect contract.

A key already on the identity at a binding's derived payload is sent again
only within the plan's level and limits; an update that lands without
confirming is settled by re-reading the identity.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The approval sheet lists each key the app is given with what it can do,
its budget and its expiry, plus how old the request is and where the
wallet returns. A refused request shows why, with nothing to approve.
After the user answers, the wallet opens the request's callback with
ac=ok, declined or failed. A refused request's callback is never opened.

The new strings are in every catalog in English.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… grant

A request that repeats another request's ephemeral key derives the same key
payloads. A key already on the identity is now sent again only when no
grant for another app or request names it, so the second request cannot
take over the first one's key or record it under its app.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…etwork its sheet was resolved for

The request the approval sheet shows now records the wallet and network
scope it was resolved for. An approval is refused, and the sheet rebuilt,
when the active wallet or network scope is another one, also when the same
wallet and identity exist under another devnet name. The check runs before
the protocol version is asked for.

The grant store also leaves alone a stored value that is not data at all
(a string, a dictionary, a number), like data that is not a list of rows:
nothing is written over it and no sign-in starts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…DashConnect approval

- The scope an operation runs for now also names where the network is
  reached (the devnet's quorum URL), so consent given for a devnet is not
  used after it is pointed at other nodes under the same name. Rows and
  grant records stay keyed by wallet and devnet name.
- When the protocol version cannot be read at approve time the approval
  fails as an unresolved login and the sheet is rebuilt: it offers "Try
  again" while it still cannot tell, and otherwise says why nothing was
  approved.
- States what `active` means for a one-QR connection.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…submitted

An identity update can land on Platform and still report a failure. The
grant was recorded only after the update returned, so such a key stayed
live with no record and no row to turn it off from.

- The grant is recorded unconfirmed (the key's hash) just before the update
  is submitted. After a reported failure the identity is read again and
  the login goes on if the key is there; otherwise the failure stands and
  the record stays unconfirmed.
- An unconfirmed record is confirmed, and its app given a row, once its own
  key (id and hash, live) is seen on the identity — at every one-QR
  approval and every disconnect. Until then it takes no part in a
  disconnect, and it is never dropped on the strength of a view that may be
  behind.
- A confirmed record is never replaced by a new unconfirmed one: a retry
  that does not see its key stops as "identity keys out of date".
- The context read for an operation checks that the SDK runtime is still
  the one it started from after the devnet settings are read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…limits; read Platform off the main actor

- A key found after a reported failure, or later, confirms its record only
  if it is the key that was submitted with everything it was given: the
  data, AUTH/HIGH/HASH160, live, the recorded budget and expiry, and a
  stored bound to the record's app. A bound the store does not show is not
  taken on trust, and an unconfirmed record no longer counts as proof of a
  key's bound when the same request is approved again.
- The App Connect response lookup and the protocol-version read run on
  their own queues instead of through the SDK's main-actor queries, so a
  network round trip no longer holds the UI.
- The protocol version a login is chosen by comes from a proved read of
  the current epoch, which fails instead of falling back; an SDK pinned to
  a version (testnet) keeps deciding by its pin, with no network read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`dash_sdk_string_free` takes a `char *`; the adapter passed the raw result
pointer, which only compiled against a header that declares it `void *`.
Also drops a doc comment left over from the previous protocol-version
lookup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…onfirmed

Recovering an unconfirmed one-QR registration only added rows for apps
that had none, so a two-QR row still waiting for its second scan kept
that banner over a live session key, and a later pass could not repair
it once the grant was confirmed. The row now becomes active and one-QR,
keeping its branding and scope.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… never saved

The one-QR login confirmed the grant and then resolved the connection
preview again (protocol version, contract metadata, username) before
saving the row. An app terminated during those reads left a live key
with a confirmed grant and no row, or an approved two-QR row without a
disconnect switch, and nothing repaired it: recovery looked only at
unconfirmed grants.

The row is now built from the approved sheet's request, so no network
read sits between the two writes. Recovery also reconciles every app
this identity holds a live key of by a confirmed grant: a missing or
two-QR row becomes an active one-QR row on the next one-QR approval or
disconnect.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
DashConnect v2 needs `deriveConnectKey` and the reshaped
`ParsedStateTransition` (platform#4844), the delete-by-values entry
point (platform#5419) and the contract-group read (platform#5421), all
merged into v5.1-dev at a9336f9486. develop's pin (5.0.0-rc.1) has none
of them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…t, and find a key id past the last one

A one-QR upgrade over a two-QR row whose identity update landed but
reported a failure left an unconfirmed record and the two-QR row. A
disconnect then took the local two-QR path, downgraded the row and
left the session key on with no switch to turn it off. The disconnect
now reads the active identity again first when it has such a record of
the app: a key confirmed there makes the row one-QR and the full
disconnect runs; a failed read, or a key that is live under the
record's id but cannot be confirmed, stops it with the row in place.

A key on the identity under the last id (an app can register one there
through the two-QR flow) made every new one-QR login fail with no free
key id. The lowest id no key has is taken instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ne-QR registration by its revision

A disconnect picked one-QR or two-QR from the row alone. A two-QR row
with a one-QR registration whose outcome was not known was turned off
locally, and the key could land afterwards with no row; a confirmed
grant whose row write was lost had its repaired row overwritten as
two-QR again.

The registration now notes the identity revision its update was built
for. Platform takes an identity update only at one above the
identity's revision, so once the identity is there without the key the
update can never land. The revocation reads the identity's keys and
revision after the PIN and then settles each pending registration of
the app: a live key that cannot be confirmed stops the disconnect, one
that can never land is dropped, and one that may still land makes the
disconnect one-QR, whose disable update leaves it unable to land; with
nothing to disable the disconnect stops with a new message. A live key
of a confirmed grant also makes it one-QR. The caller removes or
downgrades the row by what the revocation returns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…as a link

A QR code scanned off another screen is answered on that screen: opening
its callback on this phone started an unrelated session of the app in
the phone's browser. The view model knows how the request arrived, and
opens `cb` only for one delivered by `onURIReceived`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A failed attempt left `ac=failed` behind: a retry cancelled at the PIN
prompt, or a sheet rebuilt after the approval went out of date, then
closed with the earlier failure. A cancelled prompt now clears it, and
so does each rebuild, so closing the sheet reports a decline.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- A request for an app in the wallet's brand map whose callback is on a
  host the app does not have is refused (`invalid`): the sheet would be
  branded as the app and return somewhere else.
- The sheet warns when the app is not in the brand map (its name and
  website come from the request), and when a known app's request does
  not return to its website. "Only approve if you just started signing
  in on …" names the app's website first, not the request's callback.
- A key the app asked for with no budget is shown as able to spend the
  identity's credits without a limit.
- `v=2` is recognised in the form-decoded query, as the v2 parser reads
  it, so `v=%32` is no longer sent to the v1 parser.

New strings ship in English in every locale (Transifex translates).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… by its record

A key on the identity at a binding's derived payload was sent again when
its level and limits fit: a request repeating another's ephemeral key
derives the same payload, and with the grant record lost nothing tied
the key to this request. Now it is sent again only when the wallet's
store shows it with exactly the binding's bound (contract, document type
or group) and the grant recorded for this request names it. Otherwise
the approval fails closed and the app asks again.

The store's key records carry the full bound for this (`StoredBound`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…nd keep the row for another identity's

- A one-QR registration that could still land when the disconnect picked
  its keys may land before the disable update, which a reload elsewhere
  can then build on the newer identity. Once a disable update has landed
  none of them can land any more, so one more read settles each: a key
  that turned up is disabled too, one that never will is dropped, and a
  read still below the update keeps the records and the row.
- A registration on another identity of the wallet that may still land
  keeps the row (`registrationPendingOnAnotherIdentity`) instead of a
  local downgrade on this one; only that identity's own read settles it.
  This identity's own pending registration is reported first, so the
  two identities never send the user back and forth.
- A confirmed grant not yet recorded as off makes a disconnect one-QR
  while no two-QR login key is live, so a retry after a one-QR
  disconnect that stopped after disabling still removes the row.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ogin

Brings #1202 up to date: the platform pin on v5.1-dev (`getContractGroupInfo`
from dashpay/platform#5421), the reworked disconnect and the unit-test CI.

Adapted to it, and the review's remaining blocker:
- A v2 grant's keys count where the base looks at one session key: a
  confirmed record holds any of its keys, and a live one makes the
  disconnect one-QR.
- A disconnect finds the app's v2 keys that no record names: HASH160 auth
  keys at HIGH or CRITICAL with an expiry, bound to the app's contract, a
  document type on it, a group the app's owner owns (read from Platform)
  or the DashPay profile. A CRITICAL key the store cannot place stops it.
- A recorded id is disabled only while its key has the shape the grant
  registered: a v1 session key, or a v2 group key the store shows bound
  to a group.
- One update's new keys get free ids (`freeKeyIds`): the base's lowest-gap
  fallback no longer meets a `+= 1` that could reuse an id or overflow.
- A key is sent again without a record when the store shows it bound
  exactly as the binding asks: an update that landed after the wallet
  stopped waiting is answered on the retry instead of left with no row.
- A stored bound whose ids or name cannot be placed counts as unreadable.
- The owner checks read contracts off the main actor.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Disconnect finds unrecorded v2 keys bound to any contract or group the
  app's owner owns, which are the bindings the owner check lets a request
  have, not only the app's own contract (`appsV2KeyIds`, `ownedByOwner`).
  The other identities of the wallet are scanned for those shapes too,
  from the store; an owner lookup that fails leaves the row in place.
- A retry sends a recorded response again only while the encryption keys
  it carries are still the identity's: `AppConnectGrant.encryptionKeyIds`
  is recorded, and a retry whose keys changed stops with
  `appConnectEncryptionKeyChanged` before anything is registered.
- A contract group with administrators is disclosed on the sheet: they
  can add their own contracts, and a group key acts in the contracts the
  group holds when it signs.
- The budget line says it is a limit on the identity's credits, and a
  CRITICAL group key's line says that limit does not cap the tokens it
  can move.

New strings ship in English in every locale (Transifex translates).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…gn-connections

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Preliminary review — Phase 1 blocker gate

The current head incorporates the connection-state stack and its owner-attribution and identity-read fixes without base-branch drift. Static verification confirms four earlier fixes and retires findings tied to removed grant-record, two-scan, history, and expiry-check paths; five in-scope findings remain. Current CI reports simulator tests, test-target membership, workflow lint, and accessibility checks passing; no local builds or tests were run.

Validated blockers were found by the Phase-1 review and confirmed by a fresh verifier. Phase 2 is deferred until a fresh same-head revalidation clears the blocker gate.

🔴 3 blocking | 🟡 2 suggestion(s)

Still open from earlier rounds (5)

  • 🔴 Blocking: Project individual key access instead of retaining every key of an active intent — DashWallet/Sources/Models/DashConnect/AppConnectV2Login.swift:143-155 (thread)
  • 🟡 Suggestion: Approve sheet claims message access from the request, not the emitted slots — DashWallet/Sources/UI/DashConnect/ApproveConnectionSheet.swift:229-232 (thread)
  • 🟡 Suggestion: Preserve connection-detail read failures as unknown — DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2631-2634 (thread)
  • 🔴 Blocking: Do not present the largest key budget as the app's maximum — DashWallet/Sources/Models/DashConnect/DashConnectModels.swift:271-275 (thread)
  • 🔴 Blocking: Use current Platform limits for keys that have landed — DashWallet/Sources/Models/DashConnect/DashConnectModels.swift:313-320 (thread)
Review provenance

Source: reviewer 1: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); final verifier: gpt-6.1-sol (agent: sol-gate-verifier, role: verifier)

  • Triage: normal by gpt-6.1-sol (effort low) — The substantial diff adds connection UI, permission and budget projections, persisted descriptive metadata, and disconnect orchestration, but does not itself change signing, key creation or revocation mechanics, funds movement, or storage migrations.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Fresh verifier: gpt-6.1-sol — verifier; agent sol-gate-verifier
  • Phase 2 reviewers: not run (deferred by blocker gate)
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review (PastaClaw). How to work through them:
- Verify each finding against the code; fix only what is real, as narrowly as the finding.
- If a finding is wrong, decline it on its thread in one or two sentences; the bot answers once and stops.
- To defer one, link a tracking issue on its thread (or reply asking the bot to file one).
- Suggestions don't block the merge, but most are worth fixing in this PR; judge each on its merits.
- Keep the PR's scope; don't grow it to satisfy hardening suggestions.
- Carried items were raised in an earlier round: read the thread first, and don't re-fix what you already fixed, declined or deferred there. Disputed and deferred items are already handled and are not listed.

In `DashWallet/Sources/Models/DashConnect/AppConnectV2Login.swift`:
- [BLOCKING] DashWallet/Sources/Models/DashConnect/AppConnectV2Login.swift:143-155: Project individual key access instead of retaining every key of an active intent
  (carried; thread: https://github.com/dashpay/dashwallet-ios/pull/1277#discussion_r4537912336)

In `DashWallet/Sources/UI/DashConnect/ApproveConnectionSheet.swift`:
- [SUGGESTION] DashWallet/Sources/UI/DashConnect/ApproveConnectionSheet.swift:229-232: Approve sheet claims message access from the request, not the emitted slots
  (carried; thread: https://github.com/dashpay/dashwallet-ios/pull/1277#discussion_r4529856470)

In `DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift`:
- [SUGGESTION] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2631-2634: Preserve connection-detail read failures as unknown
  (carried; thread: https://github.com/dashpay/dashwallet-ios/pull/1277#discussion_r4525342328)

In `DashWallet/Sources/Models/DashConnect/DashConnectModels.swift`:
- [BLOCKING] DashWallet/Sources/Models/DashConnect/DashConnectModels.swift:271-275: Do not present the largest key budget as the app's maximum
  (carried; thread: https://github.com/dashpay/dashwallet-ios/pull/1277#discussion_r4516946944)
- [BLOCKING] DashWallet/Sources/Models/DashConnect/DashConnectModels.swift:313-320: Use current Platform limits for keys that have landed
  (carried; thread: https://github.com/dashpay/dashwallet-ios/pull/1277#discussion_r4516075964)

romchornyi and others added 5 commits November 12, 2026 14:04
#1364 was squash-merged into develop as 448accb. Takes its last two
commits, the owner scope from the pinned stores and a key on a contract
group with admins not attributed by owner, into this branch's disconnect
model; the seam test for the latter is written against this branch's
result. Also takes develop's swap and UI changes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…gn-connections

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…gn-connections

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…, and count a key under a fenced id once

An app whose intents here were all closed and that was renewed through
keys no intent names showed Disconnected, with no Disconnect, after a
disconnect whose read had a key of unknown bound: no open intent was there
to hold. Such a row now stays Confirming, with its Disconnect, until a read
places every key.

A sign-in that beat its fence was counted twice as a key still on: once
under the fenced id and again as a key the read after the update found.
The keys found after the update now leave out the ids the plan fenced.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The connection sheet built an app's access from every key of an intent that
still had a live key, with the terms the wallet submitted. It now reads the
keys on the identity: a disabled key, or one whose id another key holds,
gives nothing (no "Edit your DashPay profile" for a disabled profile key, no
funding line for it); a key that landed shows the budget and expiry Platform
holds now, which an authorized limits update may have raised; a key not
there yet shows its submitted terms while its intent may still land.

"Maximum of" is the sum of the keys' budgets: Platform counts each key's
budget apart, so that is the most the app can spend. A details read that
fails is unknown, so the sheet says so instead of showing the app's id
alone. The approve sheet says an app may receive messages: whether it gets
a key for them is known only once the approval reads the identity's
current key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
romchornyi added a commit that referenced this pull request Nov 12, 2026
…-approve-sheet

Brings #1277's connection-sheet fix. The approve sheet's permission lines
are built in ConnectionsViewModel here, so they now come from
DashConnectPermissionText.requested too: messages are said as a maybe
until the approval knows the app gets a key for them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
romchornyi and others added 2 commits November 12, 2026 15:58
…d, and tell a failed username read from no username

- A disconnect that turned off keys no approval in this wallet names says how many, and a disconnect that left keys on is shown under a neutral "Disconnected" title instead of "Success".
- A token purchase whose DPNS username read failed, with no stored name, says the name could not be checked instead of asking to create one.
- Code comments cite the ADRs this change records (0018, 0019, 0021); the app-connect README describes disconnect as it now runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…gn-connections

# Conflicts:
#	DashWallet/Sources/UI/DashConnect/Components/ConnectionRow.swift
#	DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Final validation — Phase 1 + Phase 2

This head corrects the per-key access projection, budget aggregation, and conditional message-access wording, but two blockers remain in the connection-details flow: a synchronous network query runs on the main actor, and app-wide limits omit keys already attributed to the app by the canonical projection. Simulator tests and the other code checks passed at the exact reviewed head. This verification was static; no local builds or tests were run.

🔴 2 blocking

Review provenance

Source: reviewer 1: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); reviewer 2: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 3: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); final verifier: gpt-6.1-sol (agent: sol-verifier, role: final-verifier)

  • Triage: normal by gpt-6.1-sol (effort low) — Despite its size, the diff primarily changes SwiftUI presentation, read-only projections of connection permissions and funding, and optional intent metadata rather than cryptography, key operations, funds movement, or storage migrations.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Fresh verifier: gpt-6.1-sol — final-verifier; agent sol-verifier
  • Phase 2 reviewers: gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review (PastaClaw). How to work through them:
- Verify each finding against the code; fix only what is real, as narrowly as the finding.
- If a finding is wrong, decline it on its thread in one or two sentences; the bot answers once and stops.
- To defer one, link a tracking issue on its thread (or reply asking the bot to file one).
- Suggestions don't block the merge, but most are worth fixing in this PR; judge each on its merits.
- Keep the PR's scope; don't grow it to satisfy hardening suggestions.
- Carried items were raised in an earlier round: read the thread first, and don't re-fix what you already fixed, declined or deferred there. Disputed and deferred items are already handled and are not listed.

In `DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift`:
- [BLOCKING] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2684-2685: Move the remaining-budget query off the main actor
  At the pinned platform commit dabbec09c90354fa42b508f7ff97b4bdecf3a816, fetchKeysRemainingBudgets is declared in SDK's @MainActor extension and calls dash_sdk_identity_fetch_keys_remaining_budgets synchronously, without a suspension point. The Rust entry point performs the network fetch inside runtime.block_on. Awaiting it here therefore blocks rendering and interaction for the DAPI round trip, including any retries or timeouts. Opening a landed connection triggers this path, and every rows publication while its sheet is open can trigger it again. Move the native query onto SwiftDashSDK's existing performBlockingQuery worker mechanism and consume that nonblocking API here. Task.detached around the current API is insufficient because the method still hops to the main actor.
- [BLOCKING] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2673-2675: Include attributed unrecorded keys before claiming an app-wide limit
  ConnectionAccess and the funding query consider only held intents, even when the snapshot contains additional keys that AppConnect.project attributes to this same app through unrecordedKeyIds. Those keys contribute to the canonical connection and are included by disconnectPlan, but not by this sheet's permissions, maximum budget, or connection expiry. For example, a recorded key limited to 0.5 DASH plus an enabled, known-bound, unrecorded key with unlimited spending and a later expiry still produces 'Maximum of 0.5 DASH' and the earlier connection-expiry date. The UI does not qualify these as limits of locally recorded keys. Reuse the canonical attribution to include the active identity's additional keys, deduplicate by identity/key ID, and use their authoritative limits; alternatively, explicitly present the summary as incomplete. Add a mixed recorded/unrecorded regression covering budget and expiry.

… unrecorded keys on its sheet

The connection sheet read what is left of the keys' budgets through the
SDK's main-actor query, whose FFI call blocks on the network: the UI waited
for the DAPI round trip each time a sheet opened or refreshed. It now runs
on a queue of its own (DashConnectPlatformQueries.keysRemainingBudgets),
as the epoch and contract-key reads already do.

The sheet built the app's access from its intents alone, while its row and
its disconnect also hold the keys the projection gives the app that no
intent names (another device's, or attributed by owner). Those keys now
count too, with Platform's limits: a key with no budget makes the app
unlimited, and one with no expiry leaves the connection with no end date
("with no end date" in its line). A row of such keys only gets a sheet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Final validation — Phase 1 + Phase 2

The current head fixes the previously reported attribution, budget, threading, and sheet-refresh issues, but two blocking state races remain. A details read with no identity snapshot presents submitted intent terms as verified access, and a pending disconnect confirmation can still execute after the row changes to a status that no longer permits disconnect. The SDK budget-query workaround is also duplicated in the app layer; the simulator test check is still in progress while workflow, membership, accessibility, title, and CodeRabbit checks have passed.

A pattern across this PR's review rounds

This is review round 21, and the PR has drawn 21 blocking findings so far. 20 of them share 4 underlying causes. They are listed with the other findings as usual; fixing the cause is likely to be cheaper than fixing each case.

1. Intent records are being used as Platform truth (1 new in this round, 13 earlier finding(s))

The connection sheet, approval receipt, and disconnect state derive live access from ConnectionIntent and GrantPlan fields plus optional snapshots, but those records describe what was submitted rather than which keys landed, remain enabled, were emitted, or were actually revoked. ConnectionAccess, KeyFunding, AppConnectV2Login, and the disconnect/history code each add a local exception instead of consuming one canonical per-key Platform-backed result; the absent-snapshot fallback in details(of:) is the latest instance. Fixing one missing key, limit, receipt, or disconnect outcome therefore exposes another path with the same mismatch.

In this round: Keep access unverified when no identity snapshot is available

2. Unknown reads are represented as successful values (5 earlier finding(s))

The expiry and details paths use optionals, partial dictionaries, keysOff, and phone time without a typed completeness or provenance result, while callers interpret a non-nil value as a completed check. Failure, unknown, no-expiry, and authoritative expiry states consequently collapse into the same data shape, so status, retry, and displayed details can disagree.

3. Sheet state is not bound to the current connection generation (1 new in this round, 4 earlier finding(s))

ConnectionsViewModel keeps details, expiry decisions, confirmation intent, and dismissal tasks alive across asynchronous row updates, but invalidation is based on incomplete identity such as app id or status rather than scope, grant generation, and allowed action. A later publication can therefore leave an old read, confirmation, cache entry, or timeout applicable to a different connection state. Each fix adds another guard around the existing state instead of giving the sheet one generation-bound operation model.

In this round: Recheck the allowed action when consuming disconnect confirmation

4. The SDK query boundary is missing (1 new in this round, 1 earlier finding(s))

The pinned SwiftDashSDK exposes the remaining-budget FFI query as a blocking main-actor operation, so the app added DashConnectPlatformQueries to duplicate the native invocation, lifetime handling, and parser on its own queues. That workaround fixes the immediate UI stall but leaves ownership split between the SDK API and app code, making the next query or FFI change another compatibility defect.

In this round: Move the funding-query workaround into its SDK owner

Suggested decision (redesign the component): Stop adding local guards to PlatformDashConnectDataSource and ConnectionsViewModel, and redesign the DashConnect connection-state boundary as one canonical, typed, snapshot-backed state machine. It must return verified or unknown per-key access and a durable disconnect outcome, while binding every sheet read and confirmation to wallet scope, connection generation, and current allowed action. The funding query should be exposed through SwiftDashSDK rather than duplicated in the app. Until that boundary exists, hold this PR or remove the live detail and disconnect claims that it cannot support.

If a later review again finds new blockers from these causes, it will ask for that decision and pause automatic re-review until it is made.

🔴 2 blocking | 🟡 1 suggestion(s)

Review provenance

Source: reviewer 1: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); reviewer 2: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 3: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); reviewer 4: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 5: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); final verifier: gpt-6.1-sol (agent: sol-verifier, role: final-verifier)

  • Triage: normal by gpt-6.1-sol (effort low) — This is a large, cross-cutting UI and DashConnect data-model change with substantial state, persistence, Platform data-source, localization, and test updates, but it does not directly alter funds movement, cryptography, key handling, consensus, peer-facing deserialization, or storage migrations.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Fresh final gate: an independent Phase-2 review ran after iterative findings were reconciled
  • Fresh verifier: gpt-6.1-sol — final-verifier; agent sol-verifier
  • Phase 2 reviewers: gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer
🤖 Prompt for all review comments with AI agents
Several findings on this PR share an underlying cause (the review's "pattern" section): Intent records are being used as Platform truth; Unknown reads are represented as successful values; Sheet state is not bound to the current connection generation; The SDK query boundary is missing. When you fix the findings below, fix the cause, not only the reported case. The review suggests (redesign the component): Stop adding local guards to PlatformDashConnectDataSource and ConnectionsViewModel, and redesign the DashConnect connection-state boundary as one canonical, typed, snapshot-backed state machine. It must return verified or unknown per-key access and a durable disconnect outcome, while binding every sheet read and confirmation to wallet scope, connection generation, and current allowed action. The funding query should be exposed through SwiftDashSDK rather than duplicated in the app. Until that boundary exists, hold this PR or remove the live detail and disconnect claims that it cannot support. If that decision is not yours to make, say so to the PR's author or maintainer.

These findings are from an automated code review (PastaClaw). How to work through them:
- Verify each finding against the code; fix only what is real, as narrowly as the finding.
- If a finding is wrong, decline it on its thread in one or two sentences; the bot answers once and stops.
- To defer one, link a tracking issue on its thread (or reply asking the bot to file one).
- Suggestions don't block the merge, but most are worth fixing in this PR; judge each on its merits.
- Keep the PR's scope; don't grow it to satisfy hardening suggestions.
- Carried items were raised in an earlier round: read the thread first, and don't re-fix what you already fixed, declined or deferred there. Disputed and deferred items are already handled and are not listed.

In `DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift`:
- [BLOCKING] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2670-2678: Keep access unverified when no identity snapshot is available
  When `newestSnapshots` has no entry, `?? open` treats every open intent as contributing access even though the identity has not been read. `ConnectionAccess` then exposes the intent's submitted budget, expiry, and permissions as if they were current Platform state. This also includes refused intents: refusal does not close the intent, so a cached Refused row can display permissions and funding limits for keys that never landed. Preserve an explicit unverified state when the snapshot is absent, or keep submitted/requested terms separate from verified access and funding summaries.
- [SUGGESTION] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:3723-3755: Move the funding-query workaround into its SDK owner
  `DashConnectPlatformQueries.keysRemainingBudgets` duplicates the SDK-owned FFI invocation and decimal-string/null response parser solely to avoid the main-actor hop. The pinned SwiftDashSDK already owns `fetchKeysRemainingBudgets` and provides `performBlockingQuery` for blocking FFI reads, so the threading and response-lifetime fix belongs in that SDK API rather than in a second app-local implementation. Update the platform dependency to expose the off-main budget API and remove this duplicate; platform issue #5867 should explicitly include this method if the workaround remains temporary.

In `DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift`:
- [BLOCKING] DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift:667-672: Recheck the allowed action when consuming disconnect confirmation
  `ConnectionSheet` intentionally keeps its confirmation dialog alive across row updates, but `disconnectShown()` checks only that a connection still exists. If another publication changes the row to Refused or Disconnected while the dialog is open, the sheet updates to that status while the confirmation action still calls `disconnect()`. The data source does not reject those statuses and may authorize, delete response records, or mark intents during an operation that the current `StateActions` table no longer permits. Check the current row's allowed actions both when opening the question and again when consuming its confirmation, and report that no disconnect ran when the action is no longer available.

Base automatically changed from feat/dashconnect-connection-states to develop November 12, 2026 19:39
romchornyi and others added 2 commits November 12, 2026 21:46
…rs one

The connection sheet keeps its disconnect confirmation across row updates,
but the question and the confirmation checked only that a row was still
shown. A row that turned Refused or Disconnected while the sheet asked
still ran a disconnect the state table no longer offers. Both now check the
row's current actions (StateActions) and say why nothing ran otherwise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…can spend or do

The connection sheet showed the app's funding limit, what is left of each
key's budget, when the connection ends, and what the app may do, all built
from the wallet's records and an identity read that may be missing or
behind. Those claims move to their own pull request, where they get the
per-key Platform-backed state they need. This sheet keeps the status, the
app and identity, when the connection was made, what an app is never given,
and its actions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Final validation — Phase 1 + Phase 2

Static verification at 9d6f349 confirms two remaining sheet defects: identity metadata disappears for unrecorded-only connections, and failed refreshes are concealed after details have loaded. Develop already contains the shared state/disconnect implementation through #1334; the supplied merge analysis reports nine conflicting files requiring integration. Current CI shows passing title and CodeRabbit checks with the automated review pending, but no application-build or XCTest result; no builds or tests were run in this verification.

🔴 1 blocking | 🟡 1 suggestion(s)

2 finding(s) not shown inline (GitHub refused the PR diff as too large)

🔴 Blocking: Keep identity details for connections represented only by unrecorded keys
DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2680-2681

An empty held array does not establish that the connection belongs to another identity. AppConnect.project creates connections from unrecordedKeyIds without any local intent, including restored connections and the standalone DashPay profile-key row. For these rows, this guard returns successful details without identity or username even when the cached snapshot establishes that their keys are on the active identity. ConnectionSheet.detailsCard then hides both fields on every read. The final refactor removed the unrecorded-key check along with funding, but identity attribution remains part of this sheet. Use the canonical projection and its owner attribution to recognize unrecorded keys on the active identity, return that identity and its available username, and leave the unknown connection date unset. Add coverage for an unrecorded-only connection and for a connection held exclusively by another identity.

source: gpt-6.1-sol (phase2-reviewer: general)

🟡 Suggestion: Expose a failed refresh while retaining previously loaded details
DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift:263-266

After details load successfully, same-status row publications call this method with keepingShown: true. A subsequent nil result returns before updating shownDetailsFailed, so the sheet silently retains the previous successful presentation despite the latest read failing. The renderer independently hides its failure placeholder whenever details != nil, so setting the flag alone would not fix the presentation. Retain the previous details but track and display refresh failure independently, matching the PR's stated behavior. Add a successful-read-then-failed-refresh regression; ConnectionStatusSpy currently replaces a nil answer with default successful details and cannot exercise that sequence.

source: gpt-6.1-sol (phase2-reviewer: general)

Review provenance

Source: reviewer 1: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 2: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); reviewer 3: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); final verifier: gpt-6.1-sol (agent: sol-verifier, role: final-verifier)

  • Triage: critical by gpt-6.1-sol (effort low) — The large, intricate diff changes key derivation, signing-key lifetime, and identity key registration/revocation in PlatformDashConnectDataSource.swift, including deriveSigningKeys and recordAndSubmitIdentityUpdate.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Single stage: Phase 1 and Phase 2 reviewed this head side by side, with no blocker gate between them (triage tier)
  • Fresh verifier: gpt-6.1-sol — final-verifier; agent sol-verifier
  • Phase 2 reviewers: gpt-6.1-sol — general (completed, effort xhigh); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort xhigh); agent phase2-reviewer
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review (PastaClaw). How to work through them:
- Verify each finding against the code; fix only what is real, as narrowly as the finding.
- If a finding is wrong, decline it on its thread in one or two sentences; the bot answers once and stops.
- To defer one, link a tracking issue on its thread (or reply asking the bot to file one).
- Suggestions don't block the merge, but most are worth fixing in this PR; judge each on its merits.
- Keep the PR's scope; don't grow it to satisfy hardening suggestions.
- Carried items were raised in an earlier round: read the thread first, and don't re-fix what you already fixed, declined or deferred there. Disputed and deferred items are already handled and are not listed.

In `DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift`:
- [BLOCKING] DashWallet/Sources/Models/DashConnect/PlatformDashConnectDataSource.swift:2680-2681: Keep identity details for connections represented only by unrecorded keys
  An empty `held` array does not establish that the connection belongs to another identity. `AppConnect.project` creates connections from `unrecordedKeyIds` without any local intent, including restored connections and the standalone DashPay profile-key row. For these rows, this guard returns successful details without identity or username even when the cached snapshot establishes that their keys are on the active identity. `ConnectionSheet.detailsCard` then hides both fields on every read. The final refactor removed the unrecorded-key check along with funding, but identity attribution remains part of this sheet. Use the canonical projection and its owner attribution to recognize unrecorded keys on the active identity, return that identity and its available username, and leave the unknown connection date unset. Add coverage for an unrecorded-only connection and for a connection held exclusively by another identity.

In `DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift`:
- [SUGGESTION] DashWallet/Sources/UI/DashConnect/ConnectionsViewModel.swift:263-266: Expose a failed refresh while retaining previously loaded details
  After details load successfully, same-status row publications call this method with `keepingShown: true`. A subsequent nil result returns before updating `shownDetailsFailed`, so the sheet silently retains the previous successful presentation despite the latest read failing. The renderer independently hides its failure placeholder whenever `details != nil`, so setting the flag alone would not fix the presentation. Retain the previous details but track and display refresh failure independently, matching the PR's stated behavior. Add a successful-read-then-failed-refresh regression; `ConnectionStatusSpy` currently replaces a nil answer with default successful details and cannot exercise that sequence.

romchornyi and others added 2 commits November 12, 2026 23:06
develop holds #1334 squashed (cb5ab12), whose DashConnect files are the
same as #1334's head this branch already merged (1e1ebb6): the conflicts
were #1334's changes reaching both sides, kept as this branch has them.
Brings develop's other changes (#1332, #1375, #1390, #1391, #1393).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… and says when a refresh failed

A row the projection makes from keys no intent names (a restore, another
device's grant, the profile keys) has no intent on the identity, so its
sheet took it for another identity's and showed no identity or username.
It now asks the projection, with the owners known, whether those keys are
on the active identity; the date the connection was made stays unknown.

A refresh of a sheet's details that failed kept the details shown and said
nothing. It still keeps them, and now says they could not be read again
and may be out of date.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@romchornyi

Copy link
Copy Markdown
Contributor Author

On the two findings of the last review (not shown inline: the diff was too large):

  • Keep identity details for connections represented only by unrecorded keys — fixed in 42997e1. When no intent holds the row, the details read asks the projection, with the owners known, whether the row shows unrecorded keys on the active identity (showsUnrecordedKeys), and then returns that identity and its username; the connection date stays unset. A row only another identity's intents hold still gets none. Covered by testARowOfUnrecordedKeysIsTheIdentitysWhenTheProjectionShowsThem.
  • Expose a failed refresh while retaining previously loaded details — fixed in 42997e1. A refresh that fails keeps the details shown and sets shownDetailsFailed; the sheet then says the details could not be read again and may be out of date. The spy can now fail a read (failsDetails). Covered by testARefreshThatFailsKeepsTheDetailsAndSaysSo.

The merge conflicts with develop are resolved in 3688c70: develop holds #1334 squashed, whose DashConnect files equal the #1334 head this branch had already merged.

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Final validation — Phase 1 + Phase 2

Static verification of the complete diff at 42997e1 found no blocking defect. Two non-blocking improvements remain: make the delayed-details regression actually start its first read before reopening, and reuse the tinted-red button style available in the pinned DashUIKit. Current CI shows simulator tests pending and membership, accessibility, and workflow checks passing; no local builds or tests were run.

🟡 2 suggestion(s)

Approved: nothing here blocks the merge. The non-blocking findings are optional: fix them forward, in this PR or a follow-up, without waiting for another review round.

Review provenance

Source: reviewer 1: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); reviewer 2: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 3: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); reviewer 4: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 5: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); final verifier: gpt-6.1-sol (agent: sol-verifier, role: final-verifier)

  • Triage: normal by gpt-6.1-sol (effort low) — The change is substantial but primarily adds connection presentation, details reads, save notifications and orchestration of existing disconnect behavior rather than changing signing, key revocation mechanics, funds movement or storage migrations.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Fresh final gate: an independent Phase-2 review ran after iterative findings were reconciled
  • Fresh verifier: gpt-6.1-sol — final-verifier; agent sol-verifier
  • Phase 2 reviewers: gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review (PastaClaw). How to work through them:
- Verify each finding against the code; fix only what is real, as narrowly as the finding.
- If a finding is wrong, decline it on its thread in one or two sentences; the bot answers once and stops.
- To defer one, link a tracking issue on its thread (or reply asking the bot to file one).
- Suggestions don't block the merge, but most are worth fixing in this PR; judge each on its merits.
- Keep the PR's scope; don't grow it to satisfy hardening suggestions.
- Carried items were raised in an earlier round: read the thread first, and don't re-fix what you already fixed, declined or deferred there. Disputed and deferred items are already handled and are not listed.

In `DashWalletTests/DashConnect/PlatformDashConnectDataSourceTests.swift`:
- [SUGGESTION] DashWalletTests/DashConnect/PlatformDashConnectDataSourceTests.swift:1478-1483: Start the first details read before replacing the spy's answer
  This sequence does not exercise a delayed response from the previous sheet opening. The test is main-actor isolated, and showConnection() schedules its details Task on that actor; there is no suspension before the spy's answer and delay are replaced. Both reads therefore capture the replacement answer when execution yields, so the test would pass even without the latest-read guard. Wait until the first spy call has captured its answer before hiding and reopening the sheet. A controllable continuation would make the ordering deterministic: display the second response first, then release the first response and verify it cannot overwrite the sheet.

In `DashWallet/Sources/UI/DashConnect/Components/ConnectionSheet.swift`:
- [SUGGESTION] DashWallet/Sources/UI/DashConnect/Components/ConnectionSheet.swift:289-295: Reuse the tinted-red style already supplied by pinned DashUIKit
  The comment's dependency premise is false at this head. Package.resolved pins DashUIKit to e8ae3e7fed1c6625adcbe58d65d0568d41fc7ab9, whose DashButtonStyle includes .tintedRed and owns its enabled/disabled foreground and background styling inside the button. Use that style instead of reproducing its appearance through an external background, clipping, and hit-area workaround. This keeps the connection sheet aligned with the design-system implementation and removes the inaccurate comment.

… the stale-read test races for real

The Disconnect button rebuilt a tinted red look around the plain red style,
under a comment that DashUIKit had none; the pinned DashUIKit has
.tintedRed, which now draws it. The test of a details read from an earlier
opening waited for nothing before closing the sheet, so both reads took the
second answer; it now waits until the first read has its slow answer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

@thepastaclaw thepastaclaw left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Re-review — Final validation — Phase 1 + Phase 2

The exact reviewed head has no remaining actionable in-scope findings. The simulator test suite, accessibility audit, workflow lint, and test-target membership checks succeeded; only the non-code PastaClaw review check remains in progress.

🔴 0 blocking | 🟡 0 suggestion(s) | 💬 0 nitpick(s)

Review provenance

Source: reviewer 1: muse-spark-1.3-contributor (agent: phase1-reviewer, role: general); reviewer 2: gpt-6.1-sol (agent: phase2-reviewer, role: general); reviewer 3: gpt-6.1-sol (agent: phase2-reviewer, role: security-auditor); final verifier: gpt-6.1-sol (agent: sol-verifier, role: final-verifier)

  • Triage: normal by gpt-6.1-sol (effort low) — This is a large, cross-cutting UI and DashConnect data-flow change with connection-state handling, identity reads, persistence notifications, and disconnect behavior, but it does not itself modify funds movement, cryptography, key handling, consensus, network deserialization, or storage migrations.
  • Phase 1 reviewers: muse-spark-1.3-contributor — general (completed, effort xhigh); agent phase1-reviewer
  • Phase 1 model: muse-spark-1.3-contributor — not quota-gated; passed over gemini-3.8-flash-high (antigravity quota lookup failed), glm-5.3-flash (not used above high effort; tier asks max)
  • Fresh verifier: gpt-6.1-sol — final-verifier; agent sol-verifier
  • Phase 2 reviewers: gpt-6.1-sol — general (completed, effort high); agent phase2-reviewer, gpt-6.1-sol — security-auditor (completed, effort high); agent phase2-reviewer
🤖 Prompt for all review comments with AI agents
These findings are from an automated code review. Verify the current code and confirm that no unresolved issues remain.

No unresolved findings remain from the prior review on this head.

@romchornyi-pitcrew romchornyi-pitcrew left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

✅ No blockers · no majors · 7 non-blocking recommendations — reviewed at 75a94f882d

Level Verdict
1 · Idea ✅ valid The Connections page, its rows and the connection sheet follow the Figma Connections section and the Android counterpart (dash-wallet#1662); the split into five stacked PRs keeps this one to the page and the sheet.
2 · Architecture ✅ right layer Details are read in the data source (connectionDetails), the sheet's state lives in ConnectionsViewModel, the actions come from the shared state table (ADR-0019). Views hold no SDK calls.
3 · Completeness ✅ gaps tracked What an app can spend and do is in #1399; Disconnected and Expired tabs in #1289 and #1293. Open: no device run of the current version and stale screenshots (see 6).
4 · Code ✅ clean 17 new view model / data source tests cover the sheet's races (stale reads, dismissal timeouts, a disconnect that no longer applies, another wallet's row). CI is green at this head.

Earlier threads: thepastaclaw approved this head with no open findings. 22 of its threads are still unresolved on GitHub, all outdated; 20 carry its own "Resolved / No longer applies / Withdrawn" status. The two without one — the two-QR disconnect state (finding b2dfd649) and the receipt built from reused key terms (finding 6e2a9389) — are about code that no longer exists since the move onto #1301 (no two-QR login, no grant receipts). All 22 can be resolved.

7 non-blocking recommendations
  1. Code and strings that only #1399 uses — FundingLimitsInfoSheet.swift#L25 is referenced only by its own preview, and 12 new keys have no reader in this PR (for example "Funding left", "No limit", "Connection expiry", "See what %@ will be able to do", "%1$@ left of %2$@", "App key", "DashPay profile key"). They were left behind when 9d6f349 moved the access lines to #1399. Move them there, so translators do not get strings for a screen that is not in this release if #1399 slips.
  2. administeredGroupIds is written but not read here — AppConnectProjection.swift#L77: every approval now stores it on the intent, and isAdministered(_:) (L99) is used only by a test. Fine as groundwork for #1399 (optional field, older builds ignore it); worth a line in the description.
  3. A failed details read leaves no trace — PlatformDashConnectDataSource.swift#L2665: try? turns any requireContext error into "could not be read" on the sheet, with nothing in the log. A DWLogger.log line with the error type (no identity id) would let a user report be checked.
  4. The sheet's header is hand-built — ConnectionSheet.swift#L53-L58 with the system drag indicator (ConnectionsScreen.swift#L155), while the approve sheets next to it use DashUIKit.BottomSheet since #1220. Consider the same container, or say why this one differs.
  5. A fixed 450 ms delay before the row's Disconnect question — ConnectionSheet.swift#L123-L128. It works around the presentation transition; on a slow device or with Reduce Motion the timing differs. (not verified on a device)
  6. The current version has not run on a device — the description says the screenshots are from the #1272 version and show the tab control that moved to PR 2, and that the version on #1301 (now also on #1334) has not run on a device. A fresh pair of screenshots (empty, a row, the sheet, the disconnect question) on testnet would close this.
  7. Small UI points — the row's Remove reads only "Remove" to VoiceOver (ConnectionRow.swift#L94) while Disconnect says "Disconnect %@"; the status card uses an inline Color.dash.green.opacity(0.05) (ConnectionSheet.swift#L171) rather than a DashUIKit token.
Review details

Layered review (idea → architecture → completeness → code) of the PR's own diff against develop (61 files, +5404/−293; the base already holds #1334). Checked: the new strings ship in English in every locale (28 keys, identical in all 43); no new os.Logger/print; the page keeps DashUIKit.NavigationBar; the sheet and row a11y; the intent's new field is optional for older records. Static review only: nothing was built or run.

🤖 Reviewed with Claude Code

@romchornyi
romchornyi merged commit ea3886d into develop Nov 13, 2026
7 checks passed
romchornyi added a commit that referenced this pull request Nov 13, 2026
* fix(dashconnect): a row held by a waiting record shows its grant, a landed update clears its history entry

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): funding only for confirmed grants, history cleared once the row is back

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): a waiting record keeps the keys the store gives it, and a disconnect checks its follow-up view

- A waiting record is dropped only when it holds no key by the store or
  the view (AppConnect.heldKeyIds): its re-sent keys and its added keys
  the store places count even when a lagging view omits them, unless
  the view shows them off or under another key or the store has them
  disabled; an added key live as added with no readable store record
  counts as unknown. Used by the settle and the failed-submit path.
- A disconnect lets the row go with records still waiting only when its
  follow-up view shows every auth key the store gives them
  (AppConnect.showsWaitingKeys) and none of them is held.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): the funding limits info sheet is as tall as its text

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): a later own update settles nothing; a waiting record that holds a key gets a row back

- `pendingV2Outcome` no longer takes a later update of this wallet as
  proof that a waiting one cannot land: the SDK's copy of the identity
  can be reloaded while an update is on its way. A waiting record settles
  only on its own keys, an id held by other data, or its encryption key
  under another id. `outlivedBy` is only decoded; nothing notes it.
- A waiting record that holds a key a disconnect can turn off gets a
  confirming row when the app has none offering a disconnect; a two-QR
  row waiting for its second scan is remembered for the drop.
- Another identity's waiting record holds the row only while the store
  shows it holding an auth key, so one whose update never left the device
  does not block that app's disconnects elsewhere for good; nor does it
  keep a disconnect from turning off the unattributed profile keys.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): a row a waiting record brings back keeps the app's name and its disconnected entry

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashconnect): Disconnect and Reconnect on each Connections row

Following the updated design, each row carries its action: Disconnect on
Active and Confirming rows, Reconnect on Disconnected and Expired ones.
A row's Disconnect opens the connection's sheet, which asks there, so
there is one disconnect question. The Expired sheet offers Reconnect,
with Disconnect under it: an expired connection's keys stay on Platform
until a disconnect, or a renewal of the same connection, turns them off.

What a disconnect does is read from the data source when the question is
asked (disconnectRevokesKeys), and again when it is confirmed: if it no
longer holds, nothing runs and the sheet says why. A scan is refused, with
a message, while something signs or an approval is on screen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): an incomplete expiry check says so, and the sheet follows its wallet

- An expiry read that could not tell a listed app's expiry is not shown
  as complete: the Expired tab keeps what an earlier read told and shows
  "could not be checked" with Retry. An app whose recorded keys are all
  off (`ConnectionExpiry.keysOff`) reads the same every time and does
  not ask for a retry.
- When the rows republish with another wallet's row of the app a
  connection sheet shows, the sheet closes, and its question with it.
- A connection's end date is not shown when one of its records has no
  expiry noted.
- A disconnect's history entry is dated when the revocation ends.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): expiry checks keep to their wallet and the chain's time; disconnect history and keys-off are said

- The expiry read returns the wallet it was read for. A read of another
  wallet than the rows shown is not applied, the rows switching wallet
  drop the expiries, and an earlier Expired is carried over an
  incomplete read only for a row unchanged since (no renewal). A listed
  active app with no answer makes the check incomplete.
- An app counts as expired only once both the phone's clock and the
  time of the last Core block SPV has synced are past its keys' expiry;
  until then, or without a chain time, it is not told.
- An app whose recorded keys are all off shows "Keys turned off".
- A disconnect whose app could not be saved among the disconnected apps
  says so, on the page once a closing sheet has gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashpay): take the connection expiry check out of the Connections page

The Expired tab, the expiry read from Platform and its chain time, and the
keys-off status move to a pull request of their own. The connection sheet
shows the date the keys expire under a neutral label.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashpay): take the disconnected-apps history out of the Connections page

The Disconnected tab, the history store, its writers and its clearing on a
wallet wipe, and Reconnect move to a pull request of their own. The page is
one list of the connected apps; a disconnect closes its sheet once it has
ended.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a disconnect does what its question said; grant receipts note only the keys sent

- A disconnect's question has three answers: its keys are turned off,
  only its local status changes, or either as Platform shows (a two-QR row
  with a grant). The data source holds the disconnect to the answer the
  user confirmed: before the revocation in turn, and again once the
  identity is read, before anything is turned off.
- A v2 grant record notes message access only when its response carries
  an encryption key; a retry sealed again notes it again.
- Only the latest read of the connection sheet's details is shown: one
  started before the sheet closed, opened again or read again is dropped.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a two-QR row's disconnect question does not promise a revocation

The question is told from the wallet's records alone, which do not say
which records are the active identity's: only a one-QR row is sure to turn
its keys off. A two-QR row with a grant depends on what the identity shows,
and its early two-QR return is held to the answer too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): one rule decides whether a disconnect is what its question said

A disconnect is held to its question by one rule, `accepts`, applied to
the effect the records give before the PIN prompt and to the one the
identity gives after its read. The data-source tests send the answer the
screen would have asked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a retried grant keeps its first terms; the disconnect check is one rule in one place

- A grant record keeps the keys and terms its first attempt noted: a retry
  registers those keys. Its message access follows the slots sent.
- `DashConnectDisconnectEffect.accepts` is the rule the sheet's confirm and
  the disconnect's turn both apply; the turn checks it before the PIN
  prompt, and refuses when the row is gone.
- A refused disconnect says the question changed, without "Could not
  disconnect".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the Connections page waits for its rows; one decision for a disconnect's effect

- Until the rows are delivered the page shows progress, not the empty
  state.
- `disconnectEffect` alone tells what a disconnect does from the records;
  the refusal of one whose row is gone says the connection changed.
- Leftovers of the removed disconnected-app sheet are gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a disconnect of a gone row says so; a session key's record stays one

A row gone before the disconnect's turn throws its own error, so the sheet
says the connection changed without guessing from the published rows. A
refused disconnect leaves the sheet up and its Disconnect asks again.
GrantedAccess.noted keeps isSessionKeyLogin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the Connections page follows every write to its rows

The connection store announces each save, and a data source republishes
its wallet's rows on it, so a row another data source over the same rows
removed (a page opened again while an earlier one's operation runs)
leaves the page, and its sheet closes with the reason on the page. The
mock refuses a row it does not list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): the disconnected-apps history on the Connections page

Brings back the Disconnected tab, the history store and its writers, the
sheet of a disconnected app and Reconnect, taken out of the page's first
pull request, on top of its fixes: the disconnect question's three
answers, the details read numbering and the store's save notice.

This reverts commit 5032ebfaa98dfa101f14d77f20269c6bf91fe4ec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a two-QR connection disconnected on this device is listed as disconnected

The local-only disconnect left the row approved, which reads as waiting for
the second code, with no Disconnect, no disconnect date and no Reconnect.
It now records the app among the disconnected ones and drops its row, as a
one-QR disconnect does; approving the same dash-key QR again makes a new
row, active while its keys are still registered. The data source tests
keep their history in the test suite's defaults.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the Connections page's rows and disconnected apps come in one value, under their wallet

The data source publishes a DashConnectListing: the active wallet's rows,
its disconnected apps and the scope they are of. Every sheet item carries
that scope, so the one check that closes the sheet of another wallet's row
covers a disconnected app too, including a switch between two wallets
with no rows. The view model reads no history of its own, and the screen
no longer refreshes on appear. A disconnect publishes the row gone and the
app disconnected in one value; an approval publishes the row back and the
entry forgotten. A disconnected app's sheet reads its entry again when it
is recorded again.

A two-QR disconnect that cannot be recorded among the disconnected apps
says so, as a one-QR one does. An app's entry is forgotten only while it
has a row, and a row that comes back takes the entry's name and website.
The history store's unused save is gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): the Connections page's expiry check and Expired tab

While the Connections page is on screen, the data source's expiry check
reads the active identity's keys and judges whether each active row's app
can still sign. A key is the app's when a confirmed record names it or the
store shows it bound to the app's contract; only keys that can sign are
judged. An app is expired once the phone's clock and the Core tip, by
Core's future-block margin, are past every live key's expiry; past by the
phone alone it stays active and its sheet says so. An app with live keys
that cannot sign, beside a live authentication key that cannot be matched
to an app, is undecided, which the sheet says plainly.

When to read, judge again and wait is one reducer
(ConnectionExpiryMachine) run by ConnectionExpiryChecker; the data source
tells it the rows, the identity, the page, the SDK manager and the Core
tip, the view model tells it the app came back to the foreground, and the
data source maps its read errors. The verdicts are published with the
rows, each for a row of the generation the read was made for: a wallet or
an identity change drops them, and a changed row has none until it is
read again. With no active row nothing is read. A page that appears, or an
app that comes back, moments after a read judges that read again; later it
reads anew. A clock reaching a time that can change a verdict judges the
keys already read, the latest Core tip seen counts while the SDK has none,
and waits count the time the device sleeps. Leaving the page cancels a
read, which is made when it is back. A runtime or an identity that is not
ready yet is tried again after short waits, then shown as a failed check
with Retry; a network with no identity to read says the check could not be
made, without Retry. The page gets an Expired tab with Reconnect and
Disconnect, which says "none" only when every active row was told.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): expiry is decided by the Core tip alone; a cancelled expiry read reads nothing

A key is expired once the Core tip is past its expiry by Core's
future-block margin, whatever the phone's clock says: the tip already
shows real time has passed, so a clock set back takes back no expiry. An
expiry past Int64.max is far in the future and never expired. The phone's
clock only tells an app past expiry while the tip does not show it yet,
and when to judge again. A stray key holds an app back unless the tip
shows it expired. A read from the phone's future is not fresh. A
cancelled expiry read stops before the operation gate and again once its
turn comes, without loading the identity.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): an unrecorded live profile key leaves an app past expiry undecided

A key bound to DashPay `profile` names no app: every app can be given one.
With no record naming it, the expiry check now counts it as a key whose app
cannot be told, as the disconnect already does, instead of as attributed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): settle a waiting App Connect v2 update by the revision it was submitted at

An identity update notes the revision it is submitted at (read before the
submit, raised after a failed one; a retry never lowers it), for v1 session
key registrations and v2 updates alike. A waiting v2 update whose key is
absent from an identity at that revision or past it can no longer land, and
its record is settled instead of lingering.

Platform applies an identity update only at one above the identity's
revision, so an earlier waiting update cannot land after a later update of
this wallet did: the renewal and the disconnect no longer turn keys off
after their own update. A waiting update the read after the update shows
landed keeps the disconnect's row, and is logged after a renewal.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashconnect): derive App Connect rows from the identity and a recorded intent

Replace the App Connect grant lifecycle with a projection: one identity
snapshot plus the intents this wallet recorded before each update give every
row, status and unrecorded key. An intent is written before the identity
update is submitted and is closed, not deleted, when it is done.

- v2 only: a v1 dash-key login is refused at protocol version 14.
- Disconnect adds a wallet-owned fence key at each id an unlanded intent
  would take, so a late update can no longer land, then disables it.
- A read behind the newest revision seen throws instead of overwriting state.
- Keys this wallet did not record are turned off only on an explicit confirm.
- Two-QR login keys are never offered for turning off.
- New "Confirming" status for an approval whose update may still land.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashconnect): remove the two-QR login and close review findings

The two-QR (App Connect v1) login never reached a store release, only
internal TestFlight builds. It is removed entirely: a v1 dash-key QR is
refused when scanned, a dash-st payload is taken only as a token purchase,
and the approved status, the scan-to-complete banner, the v1 key derivation
and sealing, the key-registration parser and the devnet login contract
setting go with it.

Review fixes:
- An intent counts as landed only once the keys it turns off are off too;
  the outstanding disables are submitted on their own when the keys show.
- A retry is refused when an encryption key the response carries is off,
  and when the encryption slots approved now differ from the recorded ones.
- DashPay profile keys no intent names are offered, on confirm, with the
  disconnect of an app given profile access or with no record on that
  identity, so they stay reachable after a restore.
- An unrecorded key on a contract several apps bind shows under each of
  them, and the disconnect of any of them turns it off on confirm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): keep live keys of a conflicting intent actionable and gate raised limits

- An intent keeps an actionable status while any of its auth keys is
  enabled, even when another of its ids is held by a different key: a live
  key makes it active, an expired one that is still enabled makes it
  expired. Such an intent is never resumed and gets no fence; it counts as
  never landed only once none of its auth keys is enabled.
- Before the sealed response is published, the auth keys that were already
  on the identity (an earlier try, another device) must hold no more than
  the plan approved now: no larger budget cap, no later expiry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): bind retries to their connection and recheck keys before publishing

- A retry carries on only for the same connection id; another
  connection's intent is never resumed, and the app has to ask again.
- Right before the sealed response is published the identity is read
  again: no encryption key it carries may be off, and the auth keys that
  were already there may hold no more than the plan approved now.
- DashPay profile keys no intent names are offered, on confirm, with the
  disconnect of any app: no record proves which app was given one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): publish a response only while its keys are current and usable

- Every encryption key a sealed response carries must be the key Platform
  names current for the app and purpose; a key the intent still has to
  register needs no current key yet, or that very key. This is checked on
  a retry before an update that still has to be sent, and before
  publishing on an identity read that shows the update, with reads a few
  seconds apart for a node that is behind.
- A retry, and the publication, are refused while any auth key of the
  intent is off or expired.
- A DashPay profile key no intent names stands as a connection of its own,
  so it can be turned off when no app row is left.
- A disconnect reports the identity as out of date while any key it turned
  off still shows on.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): read the app's current encryption key one way

Another key current, or the response's own key off, refuses at once,
whatever a later read says, since that read may come from a node that is
behind. No key current yet for one the identity already shows is read
again; a key one read showed current stays so, and one that never shows
current is out of date rather than changed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashconnect): answer a request at most once; show undelivered connections

A request is answered at most once, by any identity of the wallet. Once an
approval's intent is recorded, any failure of its update, of the checks
before publishing, or of the publish spends the request: the sheet shows
why, offers no Approve, the app is told the request failed, and it asks
again with a new code. A sealed response is never published by a later
attempt, since the wallet cannot prove that what it was sealed for still
holds. The retry machinery goes with it (the recorded approved slots, the
plan comparison, resumption).

A connection whose keys are live but whose response was never published
shows as "Not delivered", with Disconnect. A response that landed without
confirming is looked up on Platform when the same request is approved
again and when Connections refreshes, so a working connection is not shown
as undelivered. Superseded grants of the connection are settled whether the
approval succeeded or not.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): check the read that showed the update before publishing

When the identity update does not confirm and a re-read shows it landed,
that read is the one the checks before publishing run on (limits, keys
off, current encryption keys). A later read may come from a node that is
behind and show less, so what the landing read saw stands.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): keep a scan button and access seen on other identities

- The Connections list has a Scan QR button in the navigation bar when it
  is not empty, so a new code can be scanned after a request is spent.
- A row records the identities whose last read showed the app keys no
  approval names. A read of another identity leaves that knowledge alone,
  so the row stays, shown as active, until that identity is read again. A
  disconnect finishes on the active identity and says that keys are left on
  another one, which has to be made active to turn them off.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): tell an answered request by its whole body

A parsed App Connect request carries a SHA-256 of its bytes, and the intent
records it. Approving a request again counts as already answered only when
that digest matches: a request that reuses the key but differs in anything
else (connection, bindings, budgets, expiries) is refused as spent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): refuse every repeat approval of a request

A request is answered at most once, so a request this wallet already took,
on any identity, is shown as spent on the sheet, before any PIN, and is
refused if approved anyway. The shortcut that reported an answered request
as approved again goes, and with it the request digest it needed. Before a
response is published the wallet waits for a read that shows the whole
update, the earlier keys it turns off included.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): derive an App Connect encryption key at DIP-13 rotation 0

develop's platform pin (1721ca7a8b, with platform#5649) adds the rotation
level to application encryption keys and requires it. A v2 login derives
the first pair; later rotations and the keys from before the level are
#1258's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): refuse an App Connect request v2 for mainnet in the parser

The DIP defines `dash-key:` v2 for testnet and devnets only. The parser
now refuses `n=m` itself, so the refusal does not rest on DashConnect
being off on mainnet. Raised in review of #1204.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: record ADR-0009 for answering App Connect request v2

The decision this PR makes: a v2 request is answered with keys the
wallet derives, under limits the wallet enforces, in one identity update
the wallet signs. ADR-0009 (Proposed) with its index row, and the
app-connect feature summary extended with request v2.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): key the sheet's permission rows by position

Two rows can read the same (two encryption keys for one app), and
`ForEach(id: \.self)` needs unique ids. Also drops the stale claim that
nothing in the login flow reads `AppConnectRequest`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): bound the dash-key query before it is split or decoded

The v2 router, the v2 parser and the v1/st envelope now refuse a query
longer than 4 KiB before splitting it into parameters or form-decoding
them. The body and callback ceilings applied only after that work, and
a link routed to v1 was not bounded at all.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): tell the app when its request is refused at Approve

A refusal at Approve marks the login refused, and closing the sheet
then skipped the callback the sheet had already shown, leaving a
link-delivered app waiting. The callback now opens with the stored
status (stale, invalid, unsupported, failed) as well.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): leave the encryption slot out behind a disabled current key

Under the `latest` rule, a disabled current key of another wallet's
made the slot count as empty, so a login registered a new encryption
key and replaced the contract's current key. That is a rotation, which
is the user's explicit action and never part of a login: the slot is
now left out, waiting on a later read when a live key may be newer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): warn, not refuse, when a known app's request returns elsewhere

The wallet's brand map refused a request for a known app whose callback
was not on the app's website. The map only names an app and must not
change which requests are accepted (dips#181, App Identity): such a
request is now accepted, and the sheet warns that it would return to a
host that is not the app's website, as it already warns for an unknown
app or a known app's request without a callback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): refuse, not retry, a request that names an absent contract

A v2 request asking for a key on a contract the network proves absent
let the not-found error escape the owner lookup, so the sheet offered
"Try again" for a request that can never pass. The lookup now reads such
a contract as having no owner, and the request gets the existing refusal
for a contract the app does not own, as an absent contract group already
did. Any other failure to read still leaves the request unresolved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): refuse a v2 request for an absent app contract or document type

A v2 request whose app contract the network proves absent let the
not-found error escape preflight, so the sheet offered "Try again" for a
request that can never pass; it is now refused. A document-type binding
was checked only for the contract's owner, so a type the contract does
not define reached an approvable sheet and failed only when Platform
rejected the identity update; preflight now keeps the contracts it read,
the app's own included, and refuses a type the contract does not define.
A contract whose document types this build cannot read asks for an
update instead. Other read failures still leave the request unresolved.

The preflight now takes its contract and group reads as closures, so the
tests drive the whole path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): refuse a v2 app owned like a system contract

The system contract list missed DecisionProposals and TokenMarket, both
registered from protocol 15 at the platform pin. A request naming one as
its app, with a binding on it, passed the owner checks the way the DPNS
test describes.

Both ids are listed now, and an app whose contract has the all-zero
owner every system contract has is refused as well, so a system contract
added later is caught without updating the list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(dashconnect): drop the session-key terms from the refusal-at-Approve test

The test came with #1210's merge; this branch removed the terms argument
of the consent helper along with the session-key terms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): redesign the Connections page and add a connection sheet

The redesign of #1277, built on #1301's model instead of #1272's grant
records:

- Each connected app is one row with a Disconnect button; the row opens
  the connection's sheet, Disconnect opens it asking at once. The status
  badge goes: the sheet shows Active, Confirming or Not delivered.
- The connection sheet shows the app, its App ID, the identity and
  username, when it was connected, the funding limit and when its keys
  expire, what is left of each key's budget (read from Platform), and
  what the app can and cannot do. All of it comes from the active
  identity's intents for the app (`ConnectionDetails`, `ConnectionAccess`,
  `KeyFunding`); an intent now also notes which of its groups had
  administrators (`administeredGroupIds`, optional so older intents read).
- Disconnect asks one question: every row's keys are turned off. Keys no
  approval of this wallet names are still asked about separately after
  it, on the page once the sheet has gone.
- The approval sheet and the connection sheet share the permission lines
  (`DashConnectPermissionText`); "What are identity funding limits?"
  explains the funding limit.
- The page follows every save of its rows, by any data source over the
  same store (`UserDefaultsDashConnectStore.didSaveNotification`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): list disconnected apps on the Connections page

The disconnected-apps history of #1289, on #1301's model:

- The page has two tabs, Active and Disconnected. A disconnected app is
  listed while it has no row; its sheet shows what it was given and when
  it was disconnected, and Reconnect opens the scanner for the app's new
  code.
- The data source publishes the rows and the disconnected apps in one
  value (`DashConnectListing`). A disconnect whose app has no row left
  records the app, with its details read before its intents closed; one
  that could not be recorded is said. An approval whose update landed
  forgets the app.
- Deleting a wallet clears its disconnected apps.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): list expired connections on the Connections page

The expiry check of #1293, through #1301's projection instead of a
checker of its own:

- Until the app reads Platform's block time (dashpay/platform#5715), the
  identity snapshot takes a time Platform is known to be past: the Core
  tip SPV synced, less 2 h 70 min, how far a header can be ahead of real
  time (`AppConnect.platformTimeLowerBound`). The projection's `expired`
  status then holds once every live key is past its expiry by it.
- A row whose keys are all expired so is `ConnectionStatus.expired`, and
  is listed under a new Expired tab. Its sheet says Expired, lists what
  the app was able to do, and offers Reconnect and Disconnect: the keys
  stay on Platform until a disconnect turns them off.
- The status is judged on each read of the identity, which the page makes
  when it appears.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): DashConnect connection states from Platform and a disconnect that leaves nothing behind

Connections show Active, Confirming, Not delivered, Refused, Expired and
Disconnected, worked out from what Platform shows now plus the wallet's
record, through one state-to-actions table. A request's age and a
connection's expiry are judged by the proved block time. A request any
device already answered is refused before the PIN. dash-key codes are
refused on mainnet.

A disconnect turns off every key recorded for the app, every live key
bound to its contracts that no record names, and DashPay profile keys no
connection accounts for, without a further question, and fences a
sign-in that may still land. Every Platform write goes through one
executor that re-reads Platform after an error or a timeout; a run that
stops part-way keeps the row and says what is still live. A wallet wipe
clears the DashConnect stores.

UI here is only what the model needs: the status badge and the row read
the table (Remove on a Refused row), and the unrecorded-keys question is
gone. The approve sheet, pickers and the Connections redesign come with
the redesign stack on top.

SDD-Published-From: 407822fd0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): resolve the catalog conflict the Disconnected merge left in

The merge left conflict markers in the 43 Localizable.strings. They keep "Disconnected (connection status)" and drop the two texts of the removed history store.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashpay): leave the approve sheet's terms to the redesigned sheet

The funding limit and expiry model of the earlier approve sheet (the
ranges, presets, custom checks and the key shares of `applying`), the
sheet's facts read and the data source's protocol version read had no
caller here once that sheet moved out: the redesigned approve sheet on
top of this stack (#1278) has its own terms model. Their tests go with
them. The grant plan keeps the request's limits, as before this change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ci: stub DashConnectStores in the Core drain recovery harness

The wallet deletion it compiles now clears the wallet's DashConnect stores (AC-19); the harness stubs that edge as it does the other per-wallet stores.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs: record ADR-0015 to 0022 for DashConnect connection states and disconnect

The decisions #1334 makes, Proposed until a reviewer who is not their author approves: fence a pending sign-in, unrecorded keys off without asking, a request answered at most once, one write executor, one state table, Platform block time, Refused on the intent, disconnected apps from intents. Index and the app-connect summary updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(dashconnect): give the wallet's own gate as the reason a mainnet v2 request is refused

The parser refuses request v2 for mainnet on both carriers, as ADR-0009
records. The comment, the error text and a test comment gave the DIP as
the reason, but the DIP allows dashpay://connect on mainnet and forbids
only dash-key: there. They now say it is not enabled on mainnet yet
(ADR-0009). The doc comment of MainTabbarController.openDashConnect also
names the dashpay://connect link it handles.

Behaviour is unchanged. Follow-up to review on #1257.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): DashConnect unrecorded-only connections by Platform time, a DashPay row when nothing else can be disconnected

A connection made only of keys no intent names is Active while one of
them is live at Platform's proved time, else Expired; its keys stay in
the disconnect plan. DashPay profile keys no connection accounts for
stand as a DashPay row of their own on an identity with no connection
to disconnect, so they can always be turned off. The doc of
keysTurnedOff now says fenced key ids count.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): DashConnect connection sheet ignores a stale dismissal timeout and rereads its details on every rows update

The real dismissal and every new sheet move the dismissal number on,
so an earlier close's one-second fallback no longer marks a later
sheet gone. An open sheet reads its details again whenever the rows
are published, since another approval of the same app leaves the row
unchanged; a failed re-read keeps what the sheet shows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(dashpay): read the sheet tests' row from the Active tab

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(adr): record #1301's App Connect decisions (0027–0030)

The intent projection, v2 only, a new approval while another is
confirming, and the Not delivered row, as Proposed ADRs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): disable the app's keys after the profile keys, and record the policy as ADR-0031

- A disconnect disables the unattributed DashPay profile keys before the
  app's own keys (`AppConnect.disableOrder`). A failure part way through
  the batches now leaves an app key live while a profile key is, so the
  retry of a disconnect with no grant record still reaches the profile
  keys left instead of removing the row with one still on.
- The disconnect's comment no longer claims that a live key with an
  unreadable bound leaves the profile keys unchecked: that key stops the
  whole disconnect earlier (`sessionKeyIdsWithUnknownBinding`).
- ADR-0031 (Proposed) records the policy of turning off unattributed
  profile keys with any disconnect, and the removal of Keep.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(dashpay): describe the encryption key rules in ADR-0009 and the rule-2 test

ADR-0009's Keys bullet now states the rotation search, the earlier path
derived on testnet and devnet only, and DIP rules 1-3; the forward
reference to this change is removed. The rule-2 test's doc comment says
what it checks: the behaviour came in with #1210.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): disable the app's keys after the other keys on disconnect

Carries #1263's ADR-0031 order into the projection's disconnect: the
DashPay profile keys no intent names and any fence left on are disabled
before the app's own keys (`AppConnect.disableOrder`). An update that fails
part way then leaves an app key live while another key is, so the app's
row stays and its retry reaches the keys left. The merge of #1263 dropped
the base's version, which sorted the grant-record plan.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(dashconnect): a disconnect plan lists the profile keys before the app's keys

The merge of #1301 brings ADR-0031's order (`AppConnect.disableOrder`) into
the plan that turns off profile keys without asking.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): retry a failed response delete on the next signed operation

A disconnect whose response delete fails closes the intent with
`responseRemoved` false, and its row goes, so no disconnect of the app
reaches that response again. The next disconnect or approval on the
identity, with the PIN given, now deletes the responses of every closed
intent still marked (`AppConnect.responsesLeft`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): an update is not landed while a key's bound is unknown

A key whose contract bound the store does not hold yet may be bound to
another contract, so `hasLanded` no longer takes it as this update's and
the response with its secret is not published until the bound is read.
The row still counts the key as live.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): retry left response deletes on every signed disconnect

The retry of responses an earlier disconnect could not delete ran only
when the app being disconnected had a response of its own. It now runs
on any disconnect that signs something.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): keep the row while a disconnect leaves keys of unknown bound

A disconnect that finds keys whose bound the key store does not hold yet
cannot tell whether they are the app's. The app's newest intent now stays
open, so its row keeps Disconnect, until a read places every key; a
refresh with none left closes it and the row goes. The message says the
connection stays listed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): keep every row while a key's bound is unknown

The previous fix kept a row only through the app's newest intent left open
as Disconnected, which missed an intent that read Never landed after its
fence and a row with no intent at all. Now the rows themselves carry it:
while the read has a key whose bound the key store does not hold, no row
goes, so each keeps its Disconnect until a read places every key. A
disconnect closes its intents as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashconnect): a disconnect also turns off the app's keys on its owner's other contracts

A disconnect of an App Connect app reads the owners of the contracts and
contract groups its unrecorded keys are bound to, and turns off the keys on
the app owner's other bindings (#1346). Connections shows them under the app.
A key whose owner cannot be read, or that another connected app of the same
owner may hold, stays on its own row and the result says so; the disconnect
never reports no access left in that case (ADR-0032, ADR-0033).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: d87d3085b57c9f27c4b18c91f428ba098e933250

* docs(adr): drop the private feature-record links from ADR-0032 and ADR-0033

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: 7e2731702728501fed49de40bcc3eb2866d15c47

* docs(adr): ADR-0033 is superseded by ADR-0016 on this branch

A disconnect here asks no question about unrecorded keys (ADR-0016), so
there is no listed set to keep it to.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): bind offered keys to their identity and report what stays on from the read after the update

A key id is unique only within an identity: the keys a disconnect offers now
travel with the identity they were read on, and a disconnect with listed keys
is refused while another identity is active, before the PIN and after it.
What stays on is told from the read after the update, the one the rows are
refreshed from, so a key that landed during the update is reported (AC-08).
ADR-0032 and ADR-0033 link the PR and issue instead of private records.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: b99b438876fd3b3beab6997c16ba9035e7e3804f

* fix(dashconnect): a disconnect also turns off the app's keys on its owner's other contracts

A disconnect of an App Connect app reads the owners of the contracts and
contract groups its unrecorded keys are bound to, and turns off the keys on
the app owner's other bindings (#1346). Connections shows them under the app.
A key whose owner cannot be read, or that another connected app of the same
owner may hold, stays on its own row and the result says so; the disconnect
never reports no access left in that case (ADR-0032, ADR-0033).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: d87d3085b57c9f27c4b18c91f428ba098e933250

* docs(adr): drop the private feature-record links from ADR-0032 and ADR-0033

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: 7e2731702728501fed49de40bcc3eb2866d15c47

* fix(dashpay): bind offered keys to their identity and report what stays on from the read after the update

A key id is unique only within an identity: the keys a disconnect offers now
travel with the identity they were read on, and a disconnect with listed keys
is refused while another identity is active, before the PIN and after it.
What stays on is told from the read after the update, the one the rows are
refreshed from, so a key that landed during the update is reported (AC-08).
ADR-0032 and ADR-0033 link the PR and issue instead of private records.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: b99b438876fd3b3beab6997c16ba9035e7e3804f

* fix(dashpay): date granted App Connect keys by Platform time and refuse a keys read with lower limits

- The default and the longest expiry of a granted key are now counted from
  the proved block time, like the request's age, never from the phone's
  clock; `grantPlan` no longer takes a clock. The sum is checked and caps at
  the largest time.
- A proved keys read that shows a lower budget or an earlier expiry than the
  wallet's copy is behind it: Platform only raises a key's limits, without a
  new identity revision, so the revision check cannot tell.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): settle a disconnect's rows and result on one owner read

After a disconnect the Connections rows and what the result says stays on
were worked out from two owner reads. A failed read is tried again, so the
rows could give a sibling-contract key its own row while the result told
the user to disconnect the app again, with no row left to do it from; and
an unchanged identity reused the plan from before the PIN. Both now come
from one read of the owners on the read after the update
(settledDisconnect), on every path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): keep an App Connect row while another identity still has access

A disconnect on one identity closes that identity's intent, and the row
then showed Disconnected even when another identity of the wallet still
held the app (its open intents, or live keys its last read saw), so the
row lost its Disconnect. The row now keeps its status and that access
until the other identity's own read; with no access elsewhere it shows
Disconnected as before. Fixes #1373.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): report every key a confirmed disconnect leaves on, under the row that shows it

After the user answered the question, the result left out a listed key
that stayed on because its owner could not be read when the update was
planned. Every offered key still on after settlement is now reported as
left on. When the disconnected row is gone after settlement and another
app's row shows those keys, the message names that row instead of asking
for a second disconnect of the app.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): keep a key's raised limits across reads and DashConnect records through a failed wipe

A read of the same identity revision with a key's limits from before a
raise replaced the read that showed the raise: Platform raises a key's
budget or expiry without a new revision, and the proved keys fetch never
updates the wallet's copy that reads are held against. A read now replaces
the newest one seen only when no key of it is missing, on again, or below
its budget or expiry.

The full wipe goes on after another devnet scope's deletion fails, and
its deletion of the configured scope removed the wallet's DashConnect
records, which serve every scope. It now leaves them to the wipe's commit
point, which removes them only once every deletion succeeded.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): send the user to the row whose disconnect offers every key left on

A disconnect's result named the first row showing any key left on. Those
keys can show under several rows (a DashPay profile key under DashPay's),
so the result could send the user to a row whose disconnect leaves the
app's keys on. The row named now shows every key left on but the profile
ones, which every disconnect offers.

Closes the review thread on the retry destination (r4543058630); the
settlement refactor the review suggested is tracked in #1379.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: d18dd27c453eca937b611e97abdd94c32ee9ad84

* fix(dashpay): remember contract owners per devnet name and endpoint

The process-wide owner memory was keyed by the bare network name, which is
"devnet" for every devnet. After a switch between devnets in one run, an
owner read on the old one could attribute a key on the new one, and turn it
off after the question. Owners are now remembered per persistence scope
(which names the devnet) and endpoint, as the connection stores are.

Closes the review thread on the owner-cache scope (r4544440023).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SDD-Published-From: 7447832b2c4c4887ff32204877b2783346cdb4f4

* fix(dashpay): admit an identity read atomically, keep the later block time, and hold for a key of unknown bound that lands

Two reads at once could both pass against the same newest read, since the
check and the store took the lock apart: they are now one step. A read
whose proof is older than one already seen kept its own block time, so a
key already seen expired could show live again; an admitted read now keeps
the later block time, and only a raised expiry makes such a key live.

A disconnect decided whether to keep the app's intent open, and whether
it finished, from the keys of unknown bound in the read before the update.
A key of unknown bound that landed during the update closed the intent and
left the row Disconnected with no Disconnect. Both now use the read after
the update, and the plan's read only when that read failed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): keep a renewed app's row while a key's bound is unknown, and count a key under a fenced id once

An app whose intents here were all closed and that was renewed through
keys no intent names showed Disconnected, with no Disconnect, after a
disconnect whose read had a key of unknown bound: no open intent was there
to hold. Such a row now stays Confirming, with its Disconnect, until a read
places every key.

A sign-in that beat its fence was counted twice as a key still on: once
under the fenced id and again as a key the read after the update found.
The keys found after the update now leave out the ids the plan fenced.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the connection sheet shows what the keys on Platform give

The connection sheet built an app's access from every key of an intent that
still had a live key, with the terms the wallet submitted. It now reads the
keys on the identity: a disabled key, or one whose id another key holds,
gives nothing (no "Edit your DashPay profile" for a disabled profile key, no
funding line for it); a key that landed shows the budget and expiry Platform
holds now, which an authorized limits update may have raised; a key not
there yet shows its submitted terms while its intent may still land.

"Maximum of" is the sum of the keys' budgets: Platform counts each key's
budget apart, so that is the most the app can spend. A details read that
fails is unknown, so the sheet says so instead of showing the app's id
alone. The approve sheet says an app may receive messages: whether it gets
a key for them is known only once the approval reads the identity's
current key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): say what a disconnect turned off beyond the app's record, and tell a failed username read from no username

- A disconnect that turned off keys no approval in this wallet names says how many, and a disconnect that left keys on is shown under a neutral "Disconnected" title instead of "Success".
- A token purchase whose DPNS username read failed, with no stored name, says the name could not be checked instead of asking to create one.
- Code comments cite the ADRs this change records (0018, 0019, 0021); the app-connect README describes disconnect as it now runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): read key budgets off the main actor and count the app's unrecorded keys on its sheet

The connection sheet read what is left of the keys' budgets through the
SDK's main-actor query, whose FFI call blocks on the network: the UI waited
for the DAPI round trip each time a sheet opened or refreshed. It now runs
on a queue of its own (DashConnectPlatformQueries.keysRemainingBudgets),
as the epoch and contract-key reads already do.

The sheet built the app's access from its intents alone, while its row and
its disconnect also hold the keys the projection gives the app that no
intent names (another device's, or attributed by owner). Those keys now
count too, with Platform's limits: a key with no budget makes the app
unlimited, and one with no expiry leaves the connection with no end date
("with no end date" in its line). A row of such keys only gets a sheet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a sheet's disconnect runs only while its row still offers one

The connection sheet keeps its disconnect confirmation across row updates,
but the question and the confirmation checked only that a row was still
shown. A row that turned Refused or Disconnected while the sheet asked
still ran a disconnect the state table no longer offers. Both now check the
row's current actions (StateActions) and say why nothing ran otherwise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(dashpay): the connection sheet no longer claims what an app can spend or do

The connection sheet showed the app's funding limit, what is left of each
key's budget, when the connection ends, and what the app may do, all built
from the wallet's records and an identity read that may be missing or
behind. Those claims move to their own pull request, where they get the
per-key Platform-backed state they need. This sheet keeps the status, the
app and identity, when the connection was made, what an app is never given,
and its actions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(dashpay): the connection sheet shows what an app can spend and do

Brings back to the connection sheet what #1277 left out: the app's funding
limit (the sum of its keys' budgets), what is left of each key's budget,
when the connection ends, and what the app may do. They are built per key
from the identity read: a disabled or taken key gives nothing, a key that
landed shows Platform's current limits, a key not there yet shows its
submitted terms while its intent may still land, and keys the projection
gives the app that no intent names count too. What is left of the budgets
is read off the main actor.

This reverts commit 9d6f34980.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a connection sheet with no identity read claims no access

Without a read of the identity, the sheet built the app's access from every
open intent, refused ones included, and showed the limits they submitted as
if they had landed. ConnectionAccess now needs a read: with none, the sheet
shows no access, funding or expiry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a sheet shows the identity of a row of unrecorded keys, and says when a refresh failed

A row the projection makes from keys no intent names (a restore, another
device's grant, the profile keys) has no intent on the identity, so its
sheet took it for another identity's and showed no identity or username.
It now asks the projection, with the owners known, whether those keys are
on the active identity; the date the connection was made stays unknown.

A refresh of a sheet's details that failed kept the details shown and said
nothing. It still keeps them, and now says they could not be read again
and may be out of date.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the sheet's message access, funding lines and group warnings follow the keys on Platform

- Message access needs the intent's encryption keys still usable on the
  identity read (encryptionKeysUsable): a disabled or no longer live key no
  longer reads as "receive messages".
- Funding lines are chosen key by key from the held intents: a live key
  keeps its line when another key of its intent never landed.
- An unrecorded key on a contract group gives the administrators' warning
  when the group may have them: its owner read as administered, or not
  read (unknown is not said to be absent).
- A key with no expiry cannot reach the sheet (the projection lists only
  keys with one), so its "no end date" wording is gone.
- The off-main budget query's TODO names dashpay/platform#5867.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the sheet's Disconnect uses DashUIKit's tinted red, and the stale-read test races for real

The Disconnect button rebuilt a tinted red look around the plain red style,
under a comment that DashUIKit had none; the pinned DashUIKit has
.tintedRed, which now draws it. The test of a details read from an earlier
opening waited for nothing before closing the sheet, so both reads took the
second answer; it now waits until the first read has its slow answer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a connection sheet claims message access only from encryption keys that landed or may

The sheet asked encryptionKeysUsable, the response path's check, whose
added-key rule only rejects a disabled key: an encryption key whose id
another key holds, or one the landed update left out, still read as
"receive messages". encryptionKeysGiveAccess, in the projection, takes a
re-sent key when live and an added key when live, or not there yet while
the intent may still land.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the sheet does not show what is left of a budget above the total it read

The key totals come from the cached identity read and what is left from a
later read, so a limits update between them could show "0.02 DASH left of
0.01 DASH" under "Maximum of 0.01 DASH". When something left is above its
key's total (KeyFunding.agree), the funding lines are not shown and the
sheet says they could not be read; the next identity read brings them
together.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): the sheet claims no access through a key of unknown bound, and shows details before the budgets

- A key that matches an intent but whose bound the store does not hold yet
  may be bound elsewhere (hasLanded already refuses it): it no longer gives
  the intent's permission or a funding line. One predicate in the
  projection, AppConnect.accessKey, decides it for both.
- The sheet's details no longer wait on the remaining-budgets query: the
  data source reads them apart (connectionFunding, ConnectionFundingRead),
  and the view model adds the funding lines when they come, the latest read
  only; a refresh keeps the lines shown until its own read ends.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): keep apps disconnected on another identity, and date only what the intents record

- A read of one identity keeps a Disconnected row whose disconnect closed
  another identity's intents; it no longer removes the app from the wallet's
  Disconnected tab.
- While the store holds intents of the identity it cannot read, a refresh
  keeps the Disconnected rows: one of them may be their disconnect.
- A disconnected app with no marked intent to read has no disconnect time,
  access or connection time, instead of the row's own time.
- A disconnected app is connected at its latest approval, as the sheet of the
  live connection shows it.
- Tests for the listing the data source publishes: tabs and scope, a
  disconnect saved by another data source, a switch to a wallet with only a
  disconnected app, and a disconnected app's sheet on a wallet switch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): a funding refresh with nothing to read clears the sheet's funding lines

A refresh keeps the funding lines shown while its funding read runs, but a
read that ended with nothing to read (no key gives the app access any
more, or no identity read) left those lines and any earlier failure in
place. It now clears both.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): tell the connection sheet's access and funding from one identity read

The sheet built its access from one read of the identity and its funding
lines from another, taken later, so they could disagree: a funding line for
a key the access list did not show, or a newer total beside an older
maximum. Both now come from one ConnectionBasis (the read, the intents that
hold the app on it, and the keys no intent names). Funding is read for that
basis: only what is left of the budgets comes from the network, and the
sheet sets it only beside details told from the same basis. A refresh from
another read drops the earlier funding lines.

Every claim the sheet makes from a key on Platform (access, messages,
funding) now rests on AppConnect.placedKey: the store holds the key's bound.
An encryption key whose bound is unknown, added or sent again, no longer
gives message access.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): an Expired row tells its own connection's expiry, and expired keys elsewhere hold no row

- The sheet of an Expired row shows the expiry, limit and permissions of the
  connection the row follows (`ConnectionBasis.followedAccess`), not those of
  an older install still held.
- `seenOn` records an identity only while one of its unrecorded keys is live
  at Platform's time; keys past their expiry on another identity no longer
  keep or bring back an Active row.
- The expired-date comment tells Platform's proved block time; the tab helper
  cites ADR-0019.
- Builds on the base after #1399: ended connections keep their recorded
  access (`ConnectionDetails(recorded:)`), the sheet previews and a funding
  test use the base's API.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): build the disconnected app's sheet preview from the preview details

The preview's standalone access value is gone; the disconnected entry and its
granted lines now take the access the preview details carry, as the Loaded
preview does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): open the active row through rows(for:) in the funding refresh test

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): an Expired sheet reads the funding of the connection it follows

The sheet of an Expired row is told from `ConnectionBasis.shown(as:)`: the
intents the row follows, or its unrecorded keys when none is held. Its
access, expiry and funding lines come from that basis, so the funding read
no longer lists the keys of an older install still held. Other rows read
the whole basis as before; funding is still attached to the details of the
read it was made for.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): give a disconnected app's sheet the access its intents recorded

ConnectionDetails is told from a basis since the sheet's access and funding
come from one identity read; a connection that ended has none. It gets its
own initializer that carries the recorded access with no basis and no
funding, and the view model builds a disconnected app's details with it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(dashpay): title a disconnected app's access as what the user allowed

A disconnect also marks an intent whose update was still in flight, so the
access recorded for a disconnected app may never have landed. Its sheet now
says "See what you allowed %@ to do" instead of "was able to do", which holds
whether the keys landed or not. The new key ships in English in every locale
until the Transifex pull.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

5 participants