@domino-sdk/relay 1.66.1 → 1.68.0

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @domino-sdk/relay
 
+## 1.68.0
+
+### Minor Changes
+
+- 393abb2: **Record what your server did for a completion (experimental).** `management.completions.recordReceipt(completion, { key, network, signature, asset?, recipient?, label? })` records a receipt against a completion: the CAIP-2 network and transaction of something your server did off-platform for it, such as minting a badge. It needs `points` permission and works in live. A completion holds one receipt per `key`. Recording the same values again answers the stored receipt, and different values fail with 409 `receipt-conflict`. A completion holds at most 20 receipts (409 `receipt-limit`). `management.completions.receipts(completion)` and `domino completions receipts COMPLETION` list them. Console shows them on the accepted attempt, with a Solana Explorer link on mainnet and devnet, and marks receipts of a revoked completion. Audit history records each new receipt, and erasing a member deletes their receipts.
+- d677eee: **Badges for members who link a wallet later (experimental).** A new webhook event, `wallet.linked` (`activityTypes.walletLinked`), fires once when a member links a wallet they proved, by signing with it or signing in with it. Its `data` is `{ member, chain, network, address }` (`walletLinkedEventDataSchema`). A wallet a member import or an app login vouched for sends nothing until the member proves it. Proving a wallet that is already linked sends nothing again, and neither does an operator's relink. Subscribe to it in Console under **Settings → Webhooks** (group Members) or with `domino webhooks`. It is not in the member activity feed. `awardSolanaBadge({ ..., whenNoWallet: "defer" })` answers `{ status: "deferred" }` for a member without a proven Solana wallet. The new `awardOwedSolanaBadges({ management, event, ...badge })` from `@domino-sdk/relay/solana` handles `wallet.linked` for a Solana wallet: it mints each badge the member is owed for their counting completions of `quests`, once per completion, so a redelivered event mints nothing new. To find those completions, `management.completions.list({ member, quest?, cursor?, limit? })` and `domino completions list MEMBER [--quest QUEST]` page through a member's unrevoked completions (`read` permission).
+- 1335216: **Check-in stations on a quest (experimental).** A quest a signed Solana transaction completes can list `stations: [{ key, label, opensAt?, closesAt? }]` in `defineQuest`, up to 200. Each key is the `reference` of the station's memo (`solanaActionMemo({ quest, reference })`), and the optional window is in epoch milliseconds. Domino then takes a transaction only when its memo names one of the stations and that station was open at the transaction's block time: otherwise `management.attempts.submitSolanaTransaction()` is refused with 422 `station-unknown` or 409 `station-closed`, and a member's own submission of the quest with `station-unknown`. `perStation()` completes the quest once per member per station. Publishing refuses duplicate keys, more than 200 stations, a window that closes before it opens, and stations on any quest but a member-submitted `manual()` quest without input, or on a reusable quest type. Stations are part of the release, so promotion copies them to live and `management.quests.list()` returns them. `runQuest` refuses an unknown station, or one closed at `now`, as Domino does.
+- 30a5bae: **.sol names.** Domino reads the primary `.sol` name (Solana Name Service, on mainnet) of every linked Solana wallet, proved, sign-in or vouched, and keeps it for a day. It counts only while the wallet owns the domain, directly or by holding its NFT, so a primary domain since transferred shows nothing; an RPC outage keeps the last name read. Operators see it beside the address: `management.members.get(member)` returns an optional `name` on Solana wallets, such as `"toly.sol"`, and Console's member page shows it. The address stays the wallet's identity, and nothing looks a wallet up by its name.
+
+  Members and projects can use it as a profile name. `relay.profiles.update({ nameSource: "sol" })` follows the member's `.sol` name (422 without one); a `displayName`, or `nameSource: null`, stops following it, and an operator's **Reset name** clears it. `relay.profiles.mine()` lists the name in `nameOptions` and reports `nameSource`. Profile settings take the full order, `"sol"` included, in the new optional `defaultSources` (`profileDefaultSourcesSchema`) beside `defaults`, which still lists accounts only; a change that sends only `defaults`, as earlier SDKs do, keeps `.sol` names at their place. Console's profile settings show them as **.sol names**, and they supply a name only. Settings reads answer both fields, so `ProfileDefaultProvider` and the other closed enums gain no value. Leaderboards show the name under the existing profile rules, and a hidden profile still shows its alias. The new fields are `@experimental`. `domino stage` and `domino doctor --remote` count `.sol` names as a default source.
+
+- c071cec: **Soulbound Solana badges from your own server (experimental).** The new `@domino-sdk/relay/solana` entry has `createSolanaBadgeMint()`, which creates a non-transferable Token-2022 mint with on-mint metadata, and `awardSolanaBadge()`, which, given a verified `completion.created` event, mints one badge to the member's most recently linked proven Solana wallet with your mint authority and records the transaction as the completion's `badge` receipt. It mints once per completion, however often the event arrives: it records the signed transaction as a `badge-attempt-<n>` receipt before sending, so a redelivery while the mint is still confirming sends nothing and throws `SolanaBadgePendingError`, and a retry after a failed receipt write records the landed transaction instead of minting again. The entry needs the new optional peer dependencies `@solana/kit` and `@solana-program/token-2022`; other entries load neither, so nothing changes for apps that don't import it, including apps on `@solana/kit` 7. `./solana` itself needs kit 8.5 or later, which `@solana-program/token-2022` requires. The `solana-badge` snippet has the webhook route, the mint script and a quest for badge holders. See "Award on-chain badges on Solana" in the wallets guide.
+- 59e592e: **Solana programs written without Anchor decode too.** A `settings.solanaProgram()` setting now stores and uses a Codama IDL or a Shank IDL as well as an Anchor one, from the Program Metadata Program's canonical `idl` account or pasted in Console, so native, Pinocchio and Steel programs get decoded `instructions` in `ctx.wallet.transactions()`, decoded fields from `ctx.wallet.programAccount()`, and an `instruction` filter in `wallet.programActivity()` trackers. The decoded shape is the same as for Anchor: names as the IDL spells them, 64- and 128-bit integers as decimal strings, enums as `{ Variant: fields }`; a Codama map reads as an object keyed by each key as a string. On-chain IDLs stored with the Program Metadata format "none" are now read as JSON too. A pasted IDL in none of these formats is still refused, and the message now lists the supported formats.
+- 457f4e7: **NFT checks count compressed NFTs on Solana.** `ctx.wallet.nfts()` on a Solana collection now also counts the compressed NFTs (Metaplex Bubblegum) each linked wallet owns whose collection is the setting's and verified: Bubblegum v1 cNFTs in a Token Metadata collection and v2 cNFTs in a Core collection, on mainnet and devnet. They are added to each wallet's `count` and to `total`; the result is unchanged, with `standard` still `"metaplex"`. A compressed NFT collection is set like any other, as `solana:<cluster>/nft:<collection>`. Unverified and burnt cNFTs don't count.
+- f67451b: **NFT checks read Metaplex Core collections on Solana.** A `settings.nft()` collection can now name a Core collection's address, `solana:<cluster>/nft:<collection>`, on mainnet or devnet, and `ctx.wallet.nfts()` counts the Core assets each linked Solana wallet owns in it. Only the collection's update authority or a delegate it approved can add an asset, so every one counts. The result is unchanged: `standard` stays `"metaplex"`, and `at` is the lowest slot read. Setting a Core asset's address is refused with a message naming its collection, as an NFT in a Token Metadata collection already is. Token Metadata collections read as before. Compressed NFTs are still not counted.
+- 7e3cdef: **Quests read the SOL a member delegates to a validator.** `ctx.wallet.stake({ voteAccount })` finds every native stake account a linked Solana wallet controls, as its staker or its withdrawer, and returns the lamports delegated at the current epoch, summed, per wallet and per vote account. `total` is active stake; stake activating or deactivating this epoch is reported apart, so a quest can count new stake at once or wait for the epoch boundary. An account two linked wallets control counts once. Use it for "delegate at least X SOL to our validator": the new `validator-stake` snippet does that. The testing kit answers it from `facts.wallet.stake`. A malformed vote account and an unlinked `address` fail as `author-error`; RPC outages, including a node refusing the read, as `provider-unavailable`, never as zero stake.
+- 19190a4: **Check members in at a quest's stations with Solana Pay QR codes (experimental).** `defineStationAction({ quest, rpcUrl, linkUrl, chain?, label?, icon?, instructions?, waitUntil?, findTimeout?, management?, env? })` from `@domino-sdk/relay/server` serves a quest's check-in stations as Solana Pay transaction requests from your app, the station named by `?station=<key>`. `GET` answers the wallet's `{ label, icon }`; `POST { account }` answers `{ transaction, message }`, a transaction the member pays only the network fee for: your optional instructions, a 0-lamport transfer to the member's own wallet that names a one-time reference account, and the quest's memo with the station's key. A missing, unknown or closed station, and a quest that is closed or has no stations, are refused before anything is built. After answering, the handler looks the reference up through `rpcUrl` for up to 90 seconds and submits the signed transaction to Domino, kept running by `waitUntil` (Next.js `after`) or a Worker's execution context, where Cloudflare's 30-second `waitUntil` limit stops it after 28 seconds. `domino quests stations qr <quest> --url <https URL> [--out dir] [--force]` writes a labelled SVG QR code per station encoding `solana:` and the station's URL; its `--json` result lists the files. The new guide is "In-person quests with Solana Pay".
+- 964965f: **Quests read the state a Solana program keeps for each member's wallet.** `ctx.wallet.programAccount({ program, account, seeds })` derives the program-derived address from `seeds`, with `{ wallet: true }` standing for each linked Solana wallet's address, reads every account at one slot, and decodes its fields with the program's Anchor IDL: the IDL a `settings.solanaProgram()` setting stores, from chain or pasted in Console. A wallet without the account reads `fields: null`. Use it for "staked at least N in our program": the new `solana-program-state` snippet checks JUP staked in Jupiter's locked voter. The testing kit answers it from `facts.wallet.programAccount`. An account owned by another program or holding another account type, an account type the IDL doesn't name, a program without an IDL and seeds that don't fit fail as `author-error`; RPC outages as `provider-unavailable`.
+- 2125539: **Serve a quest as a Solana Action, a blink (experimental).** `defineQuestAction({ quest, build, linkUrl, chain?, metadata?, reference?, management?, env?, confirmTimeout? })` from `@domino-sdk/relay/server` returns a Web-standard `(request, env?) => Promise<Response>` handler for one Action URL, for a Next.js route handler or a Worker. `GET` answers the Action's card from the quest's title, instructions and image, which `metadata` overrides; an archived or paused quest, or one that can't take a transaction, gets a disabled card and its transaction is refused before the member signs. `POST { account }` calls your `build()`, which returns an unsigned `@solana/kit` transaction message (legacy or version 0), kit's compiled transaction or its bytes; the helper appends only the quest's SPL Memo (`solanaActionMemo`) and signs nothing. Throw `QuestActionRefusal` from `build` to answer the member without calling Domino. After the member signs, the blink's callback submits the signature with `management.attempts.submitSolanaTransaction()`, retries a transaction that is not final yet (and `attempt-pending`, `conflict` and `unavailable`) for about 45 seconds, and answers a completed action with the points awarded, the check's reason, or a note to check the app in a minute; an unlinked wallet gets buttons to open `linkUrl` and to check again. Every response carries the Actions CORS headers, `X-Action-Version: 2.4` and `X-Blockchain-Ids`. `actionsJson(rules?)` serves `/actions.json`, and `solanaActionHeaders()` and `decodeSolanaTransaction()` are exported too. The wallets guide and the on-chain reference describe it. `POST /management/v1/attempts/solana-transaction` now counts each Solana read against a budget of 1,500 per project environment and 3,000 across Domino every 10 minutes, since a blink exposes it to anyone: past it, it answers 429 `rate-limited` with `Retry-After` before reading, and a failed read answers 502 `unavailable` instead of 503.
+- 3b36041: **Pay a leaderboard's token pool on Solana (experimental).** For an approved settlement whose pool is in SOL or an SPL Token or Token-2022 token, `management.leaderboards.buildSolanaPayout(settlement, { network, mint, payer })` returns unsigned v0 transfer batches that pay each winner's unpaid share to their most recently linked proven Solana wallet, creating missing token accounts, with the rent and fees the paying wallet spends. The team signs and sends them; Relay holds no key. `confirmSolanaPayout(settlement, { signatures })` reads the finalized transactions and marks each share they paid, and `solanaPayouts(settlement)` lists the payouts. A failed or expired batch leaves its shares payable again, and a share is never planned twice. Refusals: `settlement-not-approved`, `pool-not-token`, `decimals-mismatch`, `insufficient-balance` and `unsupported-mint` (a Token-2022 transfer fee or hook). Settlement reads and the export gain an optional `payment` per row with a non-zero token share: `unpaid`, `pending` or `paid`, with the paying transaction. The CLI adds `domino leaderboard-settlements pay-solana` (prints the batches, or with `--keypair` signs, sends through `--rpc` and confirms them on your machine), `confirm-solana` and `payout-status`.
+- 7691ca9: **Solana smart accounts link by transaction (experimental).** A Squads vault, or any Solana account that cannot sign messages, links by executing a transaction: `relay.wallets.transactionChallenge({ chain: "solana", address })` answers a memo text, open 7 days and bound to the member, and once the account executes an SPL Memo v2 instruction carrying that text with itself as signer, `relay.wallets.linkByTransaction({ chain: "solana", address, signature })` links it after Relay reads the transaction finalized on Solana mainnet. The account links as a Solana wallet that counts toward the five, with `provedBy: "transaction"` and `proofTransaction` on `LinkedWallet`; `members get` and Console show both. New refusal codes: `transaction-not-final` (retry the same signature), `transaction-not-found`, `transaction-failed`, `proof-mismatch` and `challenge-used`, listed in `RelayErrorCode`. Transaction reads are limited to 30 per member and 600 per project environment in 10 minutes.
+- 4be9d1f: **Pay a settlement's token pool from a Squads multisig (experimental).** `management.leaderboards.buildSolanaPayout(settlement, { network, mint, squads: { multisig, proposer, vaultIndex } })` pays from the Squads v4 multisig's vault instead of a wallet: each batch is an unsigned transaction the proposer, a member with the Initiate permission, signs to create a vault transaction holding the batch's transfers and an active proposal for it. The signers approve and execute it in Squads; Relay never approves or executes. Pass one of `payer` and `squads`. A payout gains `source` (`wallet` or `squads`) and `squads` (`multisig`, `vaultIndex`, `proposer`, `accountRent`), and each batch gains `transactionIndex` and `proposal`. While a proposal is open its winners stay pending; `confirmSolanaPayout` marks them paid once the vault transaction executes, and the new batch status `rejected` releases them when the proposal is rejected, cancelled, stale before approval or closed without executing. A proposal that was never created expires with its blockhash. `squadsProposalUrl(payout, batch)` links a batch's proposal. The CLI adds `pay-solana --squads MULTISIG --proposer ADDRESS --vault-index N`; with `--keypair` it signs and sends the proposals in order as the proposer.
+- 9f07317: **Complete a quest from a Solana transaction the member signed (experimental).** An app's server puts `solanaActionMemo({ quest, reference? })` from `@domino-sdk/relay/server` in an SPL Memo instruction, the member signs the transaction in their wallet, and the server sends the signature with `management.attempts.submitSolanaTransaction({ quest, signature, chain? })` under `ingest` permission. Relay reads the transaction at `finalized` and runs a normal attempt for the member whose linked Solana wallet signed it, for a member-submitted `manual()` quest without input. The evaluator and a `keyed()` completion read the transaction as `ctx.action` (`{ kind, chain, signature, wallet, reference }`), null for every other attempt, and the attempt carries it as `action`. A repeated signature returns the first attempt. New refusal codes: `transaction-not-final` (409, with `Retry-After`: send the signature again), `transaction-failed`, `transaction-not-for-quest`, `wallet-not-linked` and `quest-not-transaction-completable`; signers of two members answer the existing `account-ambiguous`. The testing kit's `runQuest()` takes `action: { wallet, reference? }`. The wallets guide and the on-chain and error references describe it.
+- 0e76fee: **Test Solana quests with real transactions.** `domino quests fixtures <signature...> --program <program>` (`--cluster devnet`, `--wallet`, `--idl <file>`, `--out <file>`) has Relay read up to 20 finalized, successful transactions through its Solana RPC and answers them as `ctx.wallet.transactions()` would, the program's instructions decoded with the IDL saving its `settings.solanaProgram()` setting stores (or the `--idl` file), ready to use as a quest test's `facts.wallet.transactions`. It calls the new experimental `management.solana.transactionFixture({ chain, program, signatures, wallet?, idl? })`, `POST /management/v1/solana/transaction-fixtures`, which needs `read` permission, stores nothing, and allows 10 calls a minute per user and 100 an hour per organization. An unknown signature is 404 `transaction-not-found`, one not finalized yet 409 `transaction-not-final`, a failed one 422 `transaction-failed`, and a transaction that does not call the program, a wallet it does not list or a program that is not on the cluster 422 `validation-failed`. `limits.transactionFixtureSignatures` is 20.
+- 1e8f058: **Revoke a check-in station whose code leaked (experimental).** `management.quests.stations.revoke(quest, station, { reason })` and `restore(...)` (`POST /management/v1/quests/<quest>/stations/<station>/revoke` and `/restore`, permission `publish`, as pausing a quest) revoke or restore one station of a quest, recorded in the audit with the reason. Revocation is an operation of the environment, like a pause: it applies in live at once, without a promotion, and a promotion never changes it. From then on `management.attempts.submitSolanaTransaction()` refuses a transaction for the station with 409 `station-revoked`, judged when it is submitted, so one signed before the revocation is refused too; `defineStationAction` answers 409 for it before building a transaction. `management.quests.stations.list(quest)` reads each station of the quest's current release with its `status` (`open`, `closed` or `revoked`), last revocation and accepted completions. Console's quest page lists the stations, downloads each one's Solana Pay QR code as SVG or PNG for an app URL it remembers per quest and environment, and revokes or restores a station. `domino quests stations qr` draws its codes with the same helper as Console, so both print the same code, and `domino pauses list` leaves station revocations out, since `quests pause|resume` don't take them.
+- 541fd71: **Reward holding an NFT for days.** `wallet.nfts({ collection })` is a tracker source of daily NFT holding samples that Relay writes itself, sampled the way `wallet.balances()` samples balances: once per project-calendar day, at a time members can't predict, Relay counts the NFTs of one collection in every wallet of the collection's family linked by a member who joined the project, at one pinned EVM block (on Solana, every read must reach the run's pinned slot). `collection` is that of `ctx.wallet.nfts()`, counted the same way, Metaplex Core collections included, except compressed NFTs: samples don't count a Token Metadata collection's, and a Core collection with the `BubblegumV2` plugin shows `not-configured` on the tracker. Each run first checks the collection as publication checks a `settings.nft()` value, and a wrong one shows on the tracker. Each record is one wallet, keyed by its CAIP-10 account on the collection's chain; its `data` is `WalletNftSample` (`count`, `block`). Reward holding with `automatic({ tracker, where: { path: "count", gte: 1 } })` and `streak({ days })`. In SDK 1.x it is a custom source on the reserved namespace `wallet-nfts`, with the collection in the new optional `nfts` field of custom sources (`walletNftSourceSchema`); ingestion refuses the namespace, and a project and environment can have at most 5 such trackers besides its 5 `wallet.balances()` trackers (`limit-reached`).
+
+  `management.trackers.create` and Console **New tracker** take `{ kind: "wallet-nfts", collection }` (`nftTrackerCreateSchema`, beside `managedTrackerCreateSchema`, so `ManagedTrackerSource` stays as it was), and `domino trackers create --source wallet-nfts` takes `--collection`. `management.trackers.update` changes such a tracker's title and window, never its collection. The new `nft-hold-streak` snippet rewards holding one of a collection's NFTs for 30 days in a row.
+
+- ebbfa83: **Leaderboards and streaks on how members use your Solana program, with no indexer.** `wallet.programActivity({ program, chain?, instruction?, mint?, minAmount?, signer? })` is a tracker source Relay writes itself: every 10 minutes it reads the finalized, successful transactions of each Solana wallet linked by a member who joined the project, and records each one that calls `program` as a record keyed by `<signature>:<address>`, authored by the wallet's CAIP-10 account, with the block time as `occurredAt` and `WalletProgramActivity` as `data` (`signature`, `slot`, `timestamp`, `signer`, `instruction`, `amount`, `delta`). Only transactions the wallet signed count unless `signer: "any"`, and never before the wallet was linked. `instruction` narrows to one instruction of the program's Anchor IDL (publication refuses a name the IDL lacks), and `mint` with `minAmount` to transactions that move at least that much of a token. Mainnet and devnet. Triggers on it fire on `"new-record"` by default. In SDK 1.x it is a custom source on the reserved namespace `wallet-program-activity`, with its settings in the new optional `activity` field of custom sources (`walletProgramActivitySourceSchema`); ingestion refuses the namespace, and a project and environment can have at most 20 such trackers (`limit-reached`).
+
+  `management.trackers.create` takes `{ kind: "wallet-program-activity", chain, program, instruction, mint, minAmount, anySigner }`, and `domino trackers create --source wallet-program-activity` takes `--program`, `--chain`, `--instruction`, `--mint`, `--min-amount` and `--any-signer`. The new `program-activity` snippet adds a weekly "top users of our program" leaderboard and a 5-day streak quest.
+
+- 29b5d46: **Reward keeping SOL delegated for days.** `wallet.stake({ chain, voteAccount })` is a tracker source of daily Solana native stake samples that Relay writes itself, sampled the way `wallet.balances()` samples balances: once per project-calendar day, at a time members can't predict, Relay reads how much SOL every Solana wallet linked by a member who joined the project delegates, every read reaching the run's pinned slot. `chain` is `"solana"` (mainnet, the default) or Solana devnet, and `voteAccount` a validator's vote account, left out to count every validator. Each wallet counts as `ctx.wallet.stake({ address })` reads that one wallet: the stake accounts it controls as staker or withdrawer. Each record is one wallet, keyed by its CAIP-10 account on the cluster; its `data` is `WalletStakeSample` (`amount` for active stake, `activating`, `deactivating`, in lamports, and `block`). Reward keeping stake with `automatic({ tracker, where: { path: "amount", gte: ... } })` and `streak({ days })`. In SDK 1.x it is a custom source on the reserved namespace `wallet-stake`, with the cluster and vote account in the new optional `stake` field of custom sources (`walletStakeSourceSchema`); ingestion refuses the namespace, and a project and environment can have at most 5 such trackers besides its other sampled trackers (`limit-reached`).
+
+  `management.trackers.create` and Console **New tracker** take `{ kind: "wallet-stake", chain, voteAccount }` (`stakeTrackerCreateSchema`, beside `managedTrackerCreateSchema`, so `ManagedTrackerSource` stays as it was), and `domino trackers create --source wallet-stake` takes `--vote-account` and `--chain`. `management.trackers.update` changes such a tracker's title and window, never its cluster or vote account. The new `validator-stake-streak` snippet rewards keeping 10 SOL delegated to your validator for 30 days in a row and ranks this month's biggest stakers by SOL delegated.
+
+### Patch Changes
+
+- 3a7f323: **The campaign starter has a default look worth showing.** Its greyscale theme becomes an indigo accent on cool greys in light and dark, a 1.25 type scale, two radii and two shadows, all as role tokens in `src/styles.css` (`surface`, `accent`, `accent-foreground`, `accent-ink`, `success`, `warning`, `danger`, `rounded-card`, `rounded-control`, `shadow-card`, `shadow-raised`), so a rebrand still means editing tokens rather than components. The quest card and quest page states shared by the campaign and loyalty starters are finished: a photo picker with a preview, an "In review" panel that reads as pending, a rejection that shows the reason and how to retry, a completed panel with the points earned, a short celebration that respects `prefers-reduced-motion` and the next quest, plus a loading skeleton and designed empty and error states. Buttons, links and inputs meet 44 px tap targets with a visible focus ring, and every text pair meets WCAG AA contrast in both themes. The loyalty starter keeps its neutral look and gains the same role tokens. The design reference now treats the starter's default token values, not only greyscale, as an unfinished design. The campaign starter's summary in `starters` (what the starter pickers in Console and the CLI show) no longer calls it neutral; the deprecated, frozen `starterTemplates` keeps its old copy.
+- f36e965: `discoverSolanaWallets` reads Wallet Standard wallets through a shared helper, which Console uses to pay settlements on Solana from the browser wallet. Discovery behaves as before.
+- 5609fc3: **`defineQuestAction`'s `build` takes the messages `@solana/kit` program clients make (experimental).** An instruction's `data`, a compiled transaction's `messageBytes` and signatures, and the wire bytes `build` can return (such as `getTransactionEncoder().encode()`'s) now accept kit's read-only byte arrays, so a message built with an instruction from a client such as `@solana-program/memo`'s `getAddMemoInstruction()` type-checks as `build`'s return value. Behavior is unchanged.
+
+## 1.67.0
+
+### Minor Changes
+
+- 8c070ca: **Automation keys for only the projects they create.** `management.automationKeys.create` accepts `projects: []` when `createProjects` is true: the key starts with no project and reaches only the projects it creates, so an agent that starts its own throwaway projects no longer needs a key for every project. An empty list without `createProjects` is still refused, and omitting `projects` still means every project. Console's **Chosen projects** allows no project picked once **Create projects** is checked.
+- 844caae: **Yearly Checkout takes promotion codes (experimental).** `management.billing.checkout()` with `interval: "year"` opens a Checkout page with a promotion code field; monthly Checkout has none. The subscription read (`management.billing.read()`, and `subscription` in the project's plan read) gains `discount`: while a code discounts the current period, what the period costs (`amount`) instead of its list price (`listAmount`), in US cents with tax included, and when that period ends (`until`); null otherwise. A first-year code ends with the first renewal, which bills the list price. `domino billing show` prints the discount and its end.
+- e73e721: **`management.quests.listWithoutCode()` lists quests without their code.** It answers what `management.quests.list()` does, each quest's current release with archived quests included and the most recently published first, without each release's evaluator `code` (`GET /management/v1/quests/list-without-code`). Code is most of a release's size, up to a megabyte per quest, so a project's full list can reach tens of megabytes. Use the new read whenever you show or match quests rather than run them. `quests.list()` is unchanged.
+- 8b195a4: **Self-hosted wallet apps: loopback origins on Test app login keys, and `verifyWalletSignIn`.**
+
+  - **Loopback origins.** An app login key in **Test** now accepts `http://localhost:<port>`, `http://127.0.0.1:<port>` and `http://[::1]:<port>` as well as HTTPS, so `next dev` signs members in against real Domino. `identityIntegrationInputSchema` accepts them, with the message "Use an HTTPS origin, or a loopback origin such as http://localhost:3000 for a Test key." for any other `http:` origin. Relay refuses a loopback origin on a **Live** key with 400 `invalid-request`, "Live app login keys need an HTTPS origin. Loopback origins such as http://localhost:3000 work only on Test keys."
+  - **`verifyWalletSignIn`** (`@experimental`) from `@domino-sdk/relay/server` verifies a Sign-In with Ethereum (EIP-4361) or Sign-In with Solana message and its signature in your server, without calling any network: domain and URI against your origin, the nonce you issued, issue time, expiry and `Not Before`, and the chains you accept. It answers the wallet as `authenticate()` vouches for it, with its CAIP-10 `accountId`, and throws `WalletSignInError` (`isWalletSignInError`) with a `code` when it refuses. Smart-contract wallets (ERC-1271) are refused with `invalid-signature`.
+
+  The SDK now depends on `@noble/curves` and `@noble/hashes` for EVM signature checks. See [Wallet sign-in in your own Next.js app](https://console.domino.run/docs/build/self-hosted-wallet-sign-in).
+
+- 19bbb9c: Smart-contract wallets can link and sign in: Base Account, Privy and Dynamic smart wallets, and any EVM wallet that signs with ERC-1271, or ERC-6492 before it is deployed. Relay checks such a signature on the chain in the message's Chain ID line (the signer's `chainId()`), one of the EVM chains `GET /management/v1/wallet-balance-chains` lists; an EOA's signature is still checked without a network call. `walletSignatureSchema` accepts signatures up to 16,384 characters, so update the SDK before linking smart wallets: earlier releases refuse their signatures before sending them. A linked smart wallet's `LinkedWallet` has `provedOn`, the CAIP-2 network whose contract checked its latest proof, and it is an account on that chain only: quest balance, NFT, event and contract-call reads, `wallet.balances()` samples and tracker attribution use it there, the testing kit does the same, payout lists name it as `<provedOn>:<address>`, and `caip10(wallet)` names that chain and throws for another. A chain that does not answer is refused with code `unavailable` and leaves the challenge usable; smart-wallet checks are limited to 10 per member (sign-in: per client IP) and 600 per project environment in 10 minutes.
+- 1e2edc6: **Solana devnet in quests and trackers, and Anchor 1.0 IDLs.** Quest checks and trackers can read Solana devnet the way they read an EVM testnet: pass `chain: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"` (exported as `solanaDevnet`) to `ctx.wallet.balance()`, `ctx.wallet.transactions()` or `wallet.balances()`, or name a devnet collection `solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1/nft:<collection mint>` in `settings.nft()`. Reads run in test and live, against the same linked Solana wallets as mainnet. `settings.chain()` accepts the devnet ID, `management.walletBalanceChains()` lists Solana Devnet (`testnet: true`) after Solana, and `domino trackers create --chain` takes it. `ctx.wallet.transactions()` without `chain` reads mainnet and sends the request it always did. New exports: `solanaDevnet`, `isSolanaNetwork()` and the `SolanaNetwork` type.
+
+  A `settings.solanaProgram()` program is now accepted when it is an executable program on mainnet or, when mainnet has none, on devnet, so a devnet-only program can be published. Saving the setting also finds the IDL Anchor 1.0 and later publish to the Program Metadata Program, besides the legacy IDL account.
+
+  **Behaviour change: a pasted IDL now takes precedence over the program's on-chain IDL.** Before, a save replaced a pasted IDL once the program published one on chain. Now a pasted IDL stays until an operator removes it (Console's **Remove pasted IDL**, or `solanaIdls: { [key]: null }` in `quests.updateSettings()`), and Console offers **Replace IDL** for a program that publishes one.
+
+  **Breaking types.** This minor widens released types that named Solana mainnet alone, as a deliberate break (docs/releases.md#deliberate-breaks). Code that never names devnet keeps compiling and running. Code that handles every value of one of these types now meets devnet and may need a case for it: `BalanceChain`, `NftCollection`, `NftCollectionParts` (from `parseNftCollection()`), `WalletBalanceQuery`, `WalletNftsQuery`, `WalletBalanceChains`, the testing kit's `CapabilityRequest` and the CLI's tracker results (a `wallet.balances()` source's `chain`). A hand-written `WalletReader` or `EvaluationContext` that takes mainnet alone no longer fits; build fakes with `@domino-sdk/relay/testing`.
+
+  **Upgrade before adding a devnet tracker.** Earlier SDK and CLI releases cannot read a project's trackers once it has a devnet `wallet.balances()` tracker, and cannot replay an attempt that read devnet. Relay keeps devnet out of `GET /wallet-balance-chains` for clients before this release, so their `management.walletBalanceChains()` keeps working.
+
 ## 1.66.1
 
 No changes in this release.

package/dist/{accounts-_lNsiR2k.d.ts → accounts-DnpKoJCo.d.ts}

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { R as ResourceHandle, G as GroupHandle } from './tracker-data-Bl-qPIvZ.js';
-import { S as SolanaIdlSource } from './wallet-B7e06v4m.js';
+import { R as ResourceHandle, G as GroupHandle } from './tracker-data-CAK942sx.js';
+import { S as SolanaNetwork, u as SolanaIdlSource } from './wallet-DQtJelQQ.js';
 
 /**
  * The modules this SDK knows a quest can declare to enable provider readers. Project connections
@@ -2135,6 +2135,22 @@ declare const leaderboardSettlementSummarySchema: z.ZodObject<{
     approvalReason: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 type LeaderboardSettlementSummary = z.infer<typeof leaderboardSettlementSummarySchema>;
+/** @compat open */
+type KnownSettlementPaymentStatus = "unpaid" | "pending" | "paid";
+/**
+ * A winner's pool share payment: `unpaid`, `pending` while a payout batch that pays it has not
+ * landed or expired, or `paid`.
+ */
+type SettlementPaymentStatus = KnownSettlementPaymentStatus | (string & {});
+/** A row's pool share payment, on settlement reads and the export. */
+declare const settlementPaymentSchema: z.ZodObject<{
+    status: z.ZodType<SettlementPaymentStatus>;
+    network: z.ZodNullable<z.ZodString>;
+    signature: z.ZodNullable<z.ZodString>;
+    paidAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+/** A winner's pool share payment on chain: its status, network, transaction and time. */
+type SettlementPayment = z.infer<typeof settlementPaymentSchema>;
 declare const leaderboardSettlementRowSchema: z.ZodObject<{
     member: z.ZodString;
     score: z.ZodNumber;
@@ -2145,6 +2161,12 @@ declare const leaderboardSettlementRowSchema: z.ZodObject<{
     completion: z.ZodNullable<z.ZodString>;
     revokedAt: z.ZodNullable<z.ZodNumber>;
     share: z.ZodOptional<z.ZodString>;
+    payment: z.ZodOptional<z.ZodObject<{
+        status: z.ZodType<SettlementPaymentStatus>;
+        network: z.ZodNullable<z.ZodString>;
+        signature: z.ZodNullable<z.ZodString>;
+        paidAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * The pool a settlement froze, with what it allocated. `unallocated` is the part no member
@@ -2247,6 +2269,12 @@ declare const leaderboardSettlementSchema: z.ZodObject<{
         completion: z.ZodNullable<z.ZodString>;
         revokedAt: z.ZodNullable<z.ZodNumber>;
         share: z.ZodOptional<z.ZodString>;
+        payment: z.ZodOptional<z.ZodObject<{
+            status: z.ZodType<SettlementPaymentStatus>;
+            network: z.ZodNullable<z.ZodString>;
+            signature: z.ZodNullable<z.ZodString>;
+            paidAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type LeaderboardSettlement = z.infer<typeof leaderboardSettlementSchema>;
@@ -3155,6 +3183,113 @@ declare const groupMemberPageSchema: z.ZodObject<{
 /** @compat output */
 type GroupMemberPage = z.infer<typeof groupMemberPageSchema>;
 
+/** The longest `reference` a quest action's memo carries. */
+declare const maxSolanaActionReference = 64;
+/**
+ * The memo text that names a quest action: `domino:quest:<quest key>`, then `:<reference>` when
+ * there is one. `reference` (up to 64 letters, digits, `_` or `-`) tells apart the places one quest
+ * can be completed from, such as an event's check-in stations; the evaluator and a `keyed()`
+ * completion read it as `ctx.action.reference`.
+ */
+declare function solanaActionMemo(input: {
+    quest: string;
+    reference?: string;
+}): string;
+/** The quest key and reference of a quest action's memo text, or null for any other text. */
+declare function parseSolanaActionMemo(text: string): {
+    quest: string;
+    reference: string | null;
+} | null;
+/**
+ * Whether Relay completes a quest with `trigger` from a member-signed Solana transaction: only a
+ * `manual()` quest the member submits, without input, since the transaction stands in for that
+ * submission.
+ */
+declare function takesSolanaTransaction(trigger: {
+    kind: string;
+    actor?: string;
+    input?: string;
+}): boolean;
+/**
+ * A check-in station of a quest: a place members complete it from, named by the `reference` of
+ * the memo they sign. Its key is the reference, so it stays fixed once codes for it are printed.
+ * The station takes transactions whose block time falls in `opensAt <= time < closesAt`, epoch
+ * milliseconds; a bound left out leaves that side open.
+ */
+declare const questStationSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    opensAt: z.ZodOptional<z.ZodNumber>;
+    closesAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * A check-in station of a quest: `{ key, label, opensAt?, closesAt? }`.
+ *
+ * @experimental A minor release can change check-in stations.
+ */
+type QuestStation = z.infer<typeof questStationSchema>;
+/**
+ * Why `station` does not take a transaction from `blockTime` (epoch milliseconds): it is not one
+ * of the quest's stations, or closed then. Null when it takes it.
+ */
+declare function stationRefusal(stations: readonly QuestStation[], reference: string | null, blockTime: number): {
+    code: "station-unknown" | "station-closed";
+    message: string;
+} | null;
+/** A Solana transaction signature: 64 bytes in base58. */
+declare const solanaSignatureSchema: z.ZodString;
+/**
+ * What `management.attempts.submitSolanaTransaction()` sends: the quest, the signature of the
+ * transaction a member signed with the quest's memo, and its cluster, `"solana"` or the mainnet
+ * CAIP-2 ID for mainnet (the default) or the devnet one.
+ */
+declare const solanaTransactionSubmissionSchema: z.ZodObject<{
+    quest: z.ZodString;
+    signature: z.ZodString;
+    chain: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        solana: "solana";
+        "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+        "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    }>>, z.ZodTransform<"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", "solana" | "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" | "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1">>;
+}, z.core.$strict>;
+/** What `management.attempts.submitSolanaTransaction()` takes: `{ quest, signature, chain? }`. */
+type SolanaTransactionSubmission = z.input<typeof solanaTransactionSubmissionSchema>;
+/**
+ * The action that started an attempt, as the evaluator and a `keyed()` completion read it in
+ * `ctx.action`: the signed Solana transaction an app's server submitted with
+ * `management.attempts.submitSolanaTransaction()`.
+ *
+ * @experimental A minor release can change quest actions.
+ */
+type SolanaTransactionAction = {
+    kind: "solana-transaction";
+    /** The cluster the transaction landed on. */
+    chain: SolanaNetwork;
+    signature: string;
+    /** The member's linked wallet that signed it. */
+    wallet: string;
+    /** The memo's reference, or null when it has none. */
+    reference: string | null;
+};
+/** @compat open */
+type KnownAttemptActionKind = SolanaTransactionAction["kind"];
+/**
+ * An attempt's action as Relay records and returns it. `kind` is open: a later Relay can add
+ * kinds, with fields of their own.
+ */
+declare const attemptActionSchema: z.ZodObject<{
+    kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+    chain: z.ZodString;
+    signature: z.ZodString;
+    wallet: z.ZodString;
+    reference: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * @experimental A minor release can change quest actions.
+ * @compat output
+ */
+type AttemptAction = z.infer<typeof attemptActionSchema>;
+
 declare const pointsRewardSchema: z.ZodObject<{
     kind: z.ZodDefault<z.ZodLiteral<"points">>;
     balance: z.ZodString;
@@ -4260,6 +4395,12 @@ declare const questDescriptionSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     retryCooldownMs: z.ZodOptional<z.ZodNumber>;
     completionCooldownMs: z.ZodOptional<z.ZodNumber>;
+    stations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        opensAt: z.ZodOptional<z.ZodNumber>;
+        closesAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 type QuestDescription = z.infer<typeof questDescriptionSchema>;
 declare const artifactSchema: z.ZodObject<{
@@ -4722,6 +4863,12 @@ declare const storedQuestDescriptionSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     retryCooldownMs: z.ZodOptional<z.ZodNumber>;
     completionCooldownMs: z.ZodOptional<z.ZodNumber>;
+    stations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        opensAt: z.ZodOptional<z.ZodNumber>;
+        closesAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
     completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"streak">;
         days: z.ZodNumber;
@@ -5119,6 +5266,12 @@ declare const publishedReleaseSchema: z.ZodObject<{
     }, z.core.$strict>>>;
     retryCooldownMs: z.ZodOptional<z.ZodNumber>;
     completionCooldownMs: z.ZodOptional<z.ZodNumber>;
+    stations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        opensAt: z.ZodOptional<z.ZodNumber>;
+        closesAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
     completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"streak">;
         days: z.ZodNumber;
@@ -5664,6 +5817,12 @@ declare const templateSchema: z.ZodObject<{
         }, z.core.$strict>>>;
         retryCooldownMs: z.ZodOptional<z.ZodNumber>;
         completionCooldownMs: z.ZodOptional<z.ZodNumber>;
+        stations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            opensAt: z.ZodOptional<z.ZodNumber>;
+            closesAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
 }, z.core.$strip>;
 declare const quizAnswersSchema: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
@@ -5802,6 +5961,13 @@ declare const attemptSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     requestedReview: z.ZodDefault<z.ZodBoolean>;
     createdAt: z.ZodNumber;
+    action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+        chain: z.ZodString;
+        signature: z.ZodString;
+        wallet: z.ZodString;
+        reference: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type Attempt = z.infer<typeof attemptSchema>;
 /** @compat open */
@@ -5964,6 +6130,13 @@ declare const questSubmissionResultSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         requestedReview: z.ZodDefault<z.ZodBoolean>;
         createdAt: z.ZodNumber;
+        action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+            chain: z.ZodString;
+            signature: z.ZodString;
+            wallet: z.ZodString;
+            reference: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     replayed: z.ZodBoolean;
 }, z.core.$strip>;
@@ -6976,6 +7149,13 @@ declare const memberProgressSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             requestedReview: z.ZodDefault<z.ZodBoolean>;
             createdAt: z.ZodNumber;
+            action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+                chain: z.ZodString;
+                signature: z.ZodString;
+                wallet: z.ZodString;
+                reference: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     entitlements: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -7521,6 +7701,12 @@ declare const snapshotSchema: z.ZodObject<{
         }, z.core.$strict>>>;
         retryCooldownMs: z.ZodOptional<z.ZodNumber>;
         completionCooldownMs: z.ZodOptional<z.ZodNumber>;
+        stations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            opensAt: z.ZodOptional<z.ZodNumber>;
+            closesAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
         completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"streak">;
             days: z.ZodNumber;
@@ -7923,6 +8109,13 @@ declare const snapshotSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         requestedReview: z.ZodDefault<z.ZodBoolean>;
         createdAt: z.ZodNumber;
+        action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+            chain: z.ZodString;
+            signature: z.ZodString;
+            wallet: z.ZodString;
+            reference: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     balances: z.ZodArray<z.ZodObject<{
         member: z.ZodString;
@@ -8133,6 +8326,13 @@ declare const reviewItemSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         requestedReview: z.ZodDefault<z.ZodBoolean>;
         createdAt: z.ZodNumber;
+        action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+            chain: z.ZodString;
+            signature: z.ZodString;
+            wallet: z.ZodString;
+            reference: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     title: z.ZodString;
     checks: z.ZodArray<z.ZodObject<{
@@ -8217,6 +8417,13 @@ declare const reviewPageSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             requestedReview: z.ZodDefault<z.ZodBoolean>;
             createdAt: z.ZodNumber;
+            action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+                chain: z.ZodString;
+                signature: z.ZodString;
+                wallet: z.ZodString;
+                reference: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>;
         title: z.ZodString;
         checks: z.ZodArray<z.ZodObject<{
@@ -8453,4 +8660,4 @@ interface DiscordReader {
     }): Promise<DiscordMessage | null>;
 }
 
-export { leaderboardDefinitionSchema as $, type AccountConnection as A, type ProjectGroupReference as B, type CampaignDefinition as C, type QuestPresentation as D, type Entitlement as E, type QuestProfile as F, type QuizEvidence as G, type Reward as H, SignInAccountStatus as I, SignInProvider as J, type KnownAttemptStatus as K, type LeaderboardDefinition as L, type MemberCampaignEnrollmentInput as M, type SignInProviderOption as N, type SubmissionEvidence as O, type PointBalance as P, type QuestBudgetView as Q, type ReferralDefinition as R, type SignInAccount as S, type SubmitInput as T, type TieredRewardReference as U, AttemptCodeSource as V, type IntegrationModuleProvider as W, type RewardType as X, questDescriptionSchema as Y, type AuthoringIdentity as Z, type EngagementBudget as _, type Attempt as a, type QuestSettingsInput as a$, pointLedgerDeclarationSchema as a0, referralAuthoringSchema as a1, discordMessagesSourceSchema as a2, type DiscordMessageData as a3, type DiscordMessageTextData as a4, discordReactionsSourceSchema as a5, type DiscordReactionData as a6, type KnownIntegrationModule as a7, type TextReviewInput as a8, type TextResult as a9, type GroupMemberPage as aA, type GroupPage as aB, type GroupPageQuery as aC, type IntegrationProvider as aD, type KnownAttemptCodeSource as aE, type KnownCompletionSourceKind as aF, type KnownQuestSubmissionStatus as aG, type KnownRewardType as aH, type LeaderboardExclusionGroup as aI, type LeaderboardPool as aJ, type LeaderboardPoolUnit as aK, type LeaderboardSettlement as aL, type LeaderboardSettlementPolicy as aM, type LeaderboardSettlementPool as aN, type LeaderboardSettlementSummary as aO, type ManagedGroup as aP, type ManagedPointHistoryPage as aQ, type ManagedPointLedger as aR, type MemberPage as aS, type OrganizationDiscordServers as aT, type PickupAvailability as aU, type PointLedger as aV, type ProjectIntegration as aW, type PublishedRelease as aX, type QuestAvailability as aY, type QuestDescription as aZ, type QuestPresentationContent as a_, type PhotoResult as aa, type DiscordReader as ab, type Decision as ac, rewardSchema as ad, triggerSchema as ae, type IntegrationModule as af, type TieredRewardDefinition as ag, type KnownIntegrationModuleProvider as ah, defineCampaign as ai, defineGroup as aj, referralAcceptSchema as ak, submitSchema as al, engagementPageQuerySchema as am, contentPerformanceQuerySchema as an, type CompletionSource as ao, CompletionSourceKind as ap, type ContentPerformanceSnapshot as aq, type DiscordMember as ar, type DiscordMessage as as, type EngagementDefinition as at, type EngagementRuleVersionPage as au, type EntitlementCorrection as av, type EntitlementState as aw, type EvaluatorIntegrationProvider as ax, type GroupArchiveInput as ay, type GroupMember as az, AttemptStatus as b, engagementVersionPageSchema as b$, type QuestStep as b0, type QuestStepAction as b1, type QuestSubmission as b2, type QuestSubmissionResult as b3, QuestSubmissionStatus as b4, type QuestSubmissionUpdate as b5, type ReleaseInput as b6, type ReviewPage as b7, type RewardEntry as b8, type Snapshot as b9, decisionSchema as bA, deferPolicy as bB, discordMemberInputSchema as bC, discordMemberSchema as bD, discordMessageDataSchema as bE, discordMessageInputSchema as bF, discordMessageSchema as bG, discordMessageTextDataSchema as bH, discordReactionDataSchema as bI, discordResourceSourceSchema as bJ, discordRewardSchema as bK, discordServerSchema as bL, engagementArtifactSchema as bM, engagementBoundaryPageSchema as bN, engagementBudgetSchema as bO, engagementChangePreviewInputSchema as bP, engagementChangePreviewSchema as bQ, engagementChangeSchema as bR, engagementDefinitionSchema as bS, engagementDeploymentEntrySchema as bT, engagementPageSchema as bU, engagementPublishSchema as bV, engagementRuleSchema as bW, engagementRuleVersionPageSchema as bX, engagementScoreInputSchema as bY, engagementScoreSchema as bZ, engagementSettlementSchema as b_, acceptAnywaySchema as ba, accountConnectionSchema as bb, addGroupMemberSchema as bc, artifactSchema as bd, attemptSchema as be, authProviderSchema as bf, availabilityWindowSchema as bg, badgeReward as bh, badgeRewardSchema as bi, baseUnitsSchema as bj, batchReleaseSchema as bk, beginHandoverSchema as bl, campaignDefinitionSchema as bm, campaignEnrollmentInputSchema as bn, campaignEnrollmentSchema as bo, campaignViewSchema as bp, campaignWithdrawalInputSchema as bq, completionRecordSchema as br, completionSourceSchema as bs, configurePickupSchema as bt, confirmHandoverSchema as bu, contentPerformancePageSchema as bv, contentPerformanceSnapshotSchema as bw, createGroupSchema as bx, createPointLedgerSchema as by, createStockItemSchema as bz, type AuthProvider as c, photoResultSchema as c$, engagementVersionQuerySchema as c0, entitlementCorrectionSchema as c1, entitlementRecoverySchema as c2, entitlementSchema as c3, entitlementStateSchema as c4, errorSchema as c5, evaluatorIntegrationProviderSchema as c6, evaluatorProgressSchema as c7, evaluatorProtocol as c8, evaluatorProtocolSchema as c9, leaderboardPlacementSchema as cA, leaderboardPoolSchema as cB, leaderboardPoolUnitSchema as cC, leaderboardPreviewSchema as cD, leaderboardPrizeRewardSchema as cE, leaderboardPrizeSchema as cF, leaderboardQuerySchema as cG, leaderboardRowSchema as cH, leaderboardSettlementApprovalSchema as cI, leaderboardSettlementPolicySchema as cJ, leaderboardSettlementPoolSchema as cK, leaderboardSettlementRowSchema as cL, leaderboardSettlementSchema as cM, leaderboardSettlementStatusSchema as cN, leaderboardSettlementSummarySchema as cO, leaderboardSettlementUnmeasuredSchema as cP, leaderboardWindowSchema as cQ, managedGroupSchema as cR, managedPointHistoryPageSchema as cS, managedPointLedgerSchema as cT, mediaUrlSchema as cU, memberCampaignEnrollmentInputSchema as cV, memberCampaignWithdrawalInputSchema as cW, memberListSchema as cX, memberPageSchema as cY, memberProgressSchema as cZ, organizationDiscordServersSchema as c_, eventSchema as ca, evidenceRedactionInputSchema as cb, evidenceRetentionInputSchema as cc, evidenceRetentionPeriodSchema as cd, evidenceRetentionSettingInputSchema as ce, evidenceSchema as cf, groupArchiveInputSchema as cg, groupMemberPageSchema as ch, groupMemberSchema as ci, groupPageQuerySchema as cj, groupPageSchema as ck, groupReward as cl, groupRewardSchema as cm, integrationModuleProviderSchema as cn, integrationProviderSchema as co, integrationRewardSchema as cp, leaderboardArtifactSchema as cq, leaderboardAuthoringSchema as cr, leaderboardDefinitionResponseSchema as cs, leaderboardExclusionGroupBindingSchema as ct, leaderboardExclusionGroupSchema as cu, leaderboardExclusionSchema as cv, leaderboardGroupSchema as cw, leaderboardHistoryPageSchema as cx, leaderboardHistoryQuerySchema as cy, leaderboardPageSchema as cz, type AvailabilityWindow as d, signInAccountSchema as d$, pickupAllocationSchema as d0, pickupAvailabilitySchema as d1, pickupCatalogSchema as d2, pickupPolicySchema as d3, pickupSelectionSchema as d4, pointBalanceSchema as d5, pointBalancesSchema as d6, pointEntrySchema as d7, pointHistoryPageSchema as d8, pointHistoryQuerySchema as d9, questSubmissionSchema as dA, questSubmissionUpdateSchema as dB, quizAnswersSchema as dC, quizEvidenceSchema as dD, referralAccountSchema as dE, referralArtifactSchema as dF, referralControlSchema as dG, referralDefinitionSchema as dH, referralHistorySchema as dI, referralManagementSchema as dJ, referralQualificationSchema as dK, referralRelationshipSchema as dL, referralRewardResolutionSchema as dM, referralSummarySchema as dN, referralSuspensionSchema as dO, releaseSchema as dP, removeGroupMemberSchema as dQ, reservationSchema as dR, retryCooldownMsSchema as dS, retryCooldownPolicy as dT, reviewItemSchema as dU, reviewListSchema as dV, reviewModeSchema as dW, reviewPageSchema as dX, rewardBundleSchema as dY, rewardEntrySchema as dZ, rewardKey as d_, pointLedgerArtifactSchema as da, pointLedgerPropertiesSchema as db, pointLedgerReferenceSchema as dc, pointLedgerSchema as dd, pointsAccountSchema as de, pointsEntrySchema as df, pointsMutationSchema as dg, pointsResultSchema as dh, pointsRewardSchema as di, projectGroupKey as dj, projectGroupSchema as dk, projectIntegrationSchema as dl, publishedLeaderboardSchema as dm, publishedReferralSchema as dn, publishedReleaseSchema as dp, questAvailabilitySchema as dq, questBudgetViewSchema as dr, questPresentationContentSchema as ds, questPresentationRequirementSchema as dt, questPresentationSchema as du, questProfileSchema as dv, questSettingsInputSchema as dw, questStepActionSchema as dx, questStepSchema as dy, questSubmissionResultSchema as dz, type CampaignEnrollment as e, signInProviderInputSchema as e0, signInProviderOptionSchema as e1, signInProviderSchema as e2, snapshotSchema as e3, staffDecisionSchema as e4, stockItemSchema as e5, stockSchema as e6, storedQuestDescriptionSchema as e7, storedReviewModeSchema as e8, submissionEvidenceSchema as e9, templateSchema as ea, textResultSchema as eb, textReviewInputSchema as ec, tierRewardSchema as ed, tieredRewardDefinitionSchema as ee, tieredRewardReferenceSchema as ef, updateGroupSchema as eg, type CampaignEnrollmentInput as f, type CampaignView as g, type CampaignWithdrawalInput as h, type EvaluatorProgress as i, type KnownPointEntryKind as j, type KnownSignInAccountStatus as k, type KnownSignInProvider as l, type LeaderboardHistoryPage as m, type LeaderboardHistoryQuery as n, type LeaderboardPage as o, type LeaderboardPlacement as p, type LeaderboardQuery as q, type MemberCampaignWithdrawalInput as r, type MemberProgress as s, type PointBalances as t, type PointEntry as u, PointEntryKind as v, type PointHistoryPage as w, type PointHistoryQuery as x, type PointLedgerReference as y, type ProjectGroup as z };
+export { type EngagementBudget as $, type AccountConnection as A, type ProjectGroupReference as B, type CampaignDefinition as C, type QuestPresentation as D, type Entitlement as E, type QuestProfile as F, type QuizEvidence as G, type Reward as H, SignInAccountStatus as I, SignInProvider as J, type KnownAttemptStatus as K, type LeaderboardDefinition as L, type MemberCampaignEnrollmentInput as M, type SignInProviderOption as N, type SubmissionEvidence as O, type PointBalance as P, type QuestBudgetView as Q, type ReferralDefinition as R, type SignInAccount as S, type SubmitInput as T, type TieredRewardReference as U, type KnownAttemptActionKind as V, AttemptCodeSource as W, type IntegrationModuleProvider as X, type RewardType as Y, questDescriptionSchema as Z, type AuthoringIdentity as _, type Attempt as a, type PointLedger as a$, leaderboardDefinitionSchema as a0, pointLedgerDeclarationSchema as a1, referralAuthoringSchema as a2, discordMessagesSourceSchema as a3, type DiscordMessageData as a4, type DiscordMessageTextData as a5, discordReactionsSourceSchema as a6, type DiscordReactionData as a7, type KnownIntegrationModule as a8, type SolanaTransactionAction as a9, type EntitlementCorrection as aA, type EntitlementState as aB, type EvaluatorIntegrationProvider as aC, type GroupArchiveInput as aD, type GroupMember as aE, type GroupMemberPage as aF, type GroupPage as aG, type GroupPageQuery as aH, type IntegrationProvider as aI, type KnownAttemptCodeSource as aJ, type KnownCompletionSourceKind as aK, type KnownQuestSubmissionStatus as aL, type KnownRewardType as aM, type KnownSettlementPaymentStatus as aN, type LeaderboardExclusionGroup as aO, type LeaderboardPool as aP, type LeaderboardPoolUnit as aQ, type LeaderboardSettlement as aR, type LeaderboardSettlementPolicy as aS, type LeaderboardSettlementPool as aT, type LeaderboardSettlementSummary as aU, type ManagedGroup as aV, type ManagedPointHistoryPage as aW, type ManagedPointLedger as aX, type MemberPage as aY, type OrganizationDiscordServers as aZ, type PickupAvailability as a_, type TextReviewInput as aa, type TextResult as ab, type PhotoResult as ac, type DiscordReader as ad, type Decision as ae, rewardSchema as af, triggerSchema as ag, type IntegrationModule as ah, type QuestStation as ai, type TieredRewardDefinition as aj, type KnownIntegrationModuleProvider as ak, defineCampaign as al, defineGroup as am, referralAcceptSchema as an, submitSchema as ao, engagementPageQuerySchema as ap, contentPerformanceQuerySchema as aq, stationRefusal as ar, type AttemptAction as as, type CompletionSource as at, CompletionSourceKind as au, type ContentPerformanceSnapshot as av, type DiscordMember as aw, type DiscordMessage as ax, type EngagementDefinition as ay, type EngagementRuleVersionPage as az, AttemptStatus as b, engagementDefinitionSchema as b$, type ProjectIntegration as b0, type PublishedRelease as b1, type QuestAvailability as b2, type QuestDescription as b3, type QuestPresentationContent as b4, type QuestSettingsInput as b5, type QuestStep as b6, type QuestStepAction as b7, type QuestSubmission as b8, type QuestSubmissionResult as b9, completionRecordSchema as bA, completionSourceSchema as bB, configurePickupSchema as bC, confirmHandoverSchema as bD, contentPerformancePageSchema as bE, contentPerformanceSnapshotSchema as bF, createGroupSchema as bG, createPointLedgerSchema as bH, createStockItemSchema as bI, decisionSchema as bJ, deferPolicy as bK, discordMemberInputSchema as bL, discordMemberSchema as bM, discordMessageDataSchema as bN, discordMessageInputSchema as bO, discordMessageSchema as bP, discordMessageTextDataSchema as bQ, discordReactionDataSchema as bR, discordResourceSourceSchema as bS, discordRewardSchema as bT, discordServerSchema as bU, engagementArtifactSchema as bV, engagementBoundaryPageSchema as bW, engagementBudgetSchema as bX, engagementChangePreviewInputSchema as bY, engagementChangePreviewSchema as bZ, engagementChangeSchema as b_, QuestSubmissionStatus as ba, type QuestSubmissionUpdate as bb, type ReleaseInput as bc, type ReviewPage as bd, type RewardEntry as be, type SettlementPayment as bf, type SettlementPaymentStatus as bg, type Snapshot as bh, acceptAnywaySchema as bi, accountConnectionSchema as bj, addGroupMemberSchema as bk, artifactSchema as bl, attemptActionSchema as bm, attemptSchema as bn, authProviderSchema as bo, availabilityWindowSchema as bp, badgeReward as bq, badgeRewardSchema as br, baseUnitsSchema as bs, batchReleaseSchema as bt, beginHandoverSchema as bu, campaignDefinitionSchema as bv, campaignEnrollmentInputSchema as bw, campaignEnrollmentSchema as bx, campaignViewSchema as by, campaignWithdrawalInputSchema as bz, type AuthProvider as c, managedPointHistoryPageSchema as c$, engagementDeploymentEntrySchema as c0, engagementPageSchema as c1, engagementPublishSchema as c2, engagementRuleSchema as c3, engagementRuleVersionPageSchema as c4, engagementScoreInputSchema as c5, engagementScoreSchema as c6, engagementSettlementSchema as c7, engagementVersionPageSchema as c8, engagementVersionQuerySchema as c9, leaderboardAuthoringSchema as cA, leaderboardDefinitionResponseSchema as cB, leaderboardExclusionGroupBindingSchema as cC, leaderboardExclusionGroupSchema as cD, leaderboardExclusionSchema as cE, leaderboardGroupSchema as cF, leaderboardHistoryPageSchema as cG, leaderboardHistoryQuerySchema as cH, leaderboardPageSchema as cI, leaderboardPlacementSchema as cJ, leaderboardPoolSchema as cK, leaderboardPoolUnitSchema as cL, leaderboardPreviewSchema as cM, leaderboardPrizeRewardSchema as cN, leaderboardPrizeSchema as cO, leaderboardQuerySchema as cP, leaderboardRowSchema as cQ, leaderboardSettlementApprovalSchema as cR, leaderboardSettlementPolicySchema as cS, leaderboardSettlementPoolSchema as cT, leaderboardSettlementRowSchema as cU, leaderboardSettlementSchema as cV, leaderboardSettlementStatusSchema as cW, leaderboardSettlementSummarySchema as cX, leaderboardSettlementUnmeasuredSchema as cY, leaderboardWindowSchema as cZ, managedGroupSchema as c_, entitlementCorrectionSchema as ca, entitlementRecoverySchema as cb, entitlementSchema as cc, entitlementStateSchema as cd, errorSchema as ce, evaluatorIntegrationProviderSchema as cf, evaluatorProgressSchema as cg, evaluatorProtocol as ch, evaluatorProtocolSchema as ci, eventSchema as cj, evidenceRedactionInputSchema as ck, evidenceRetentionInputSchema as cl, evidenceRetentionPeriodSchema as cm, evidenceRetentionSettingInputSchema as cn, evidenceSchema as co, groupArchiveInputSchema as cp, groupMemberPageSchema as cq, groupMemberSchema as cr, groupPageQuerySchema as cs, groupPageSchema as ct, groupReward as cu, groupRewardSchema as cv, integrationModuleProviderSchema as cw, integrationProviderSchema as cx, integrationRewardSchema as cy, leaderboardArtifactSchema as cz, type AvailabilityWindow as d, retryCooldownMsSchema as d$, managedPointLedgerSchema as d0, mediaUrlSchema as d1, memberCampaignEnrollmentInputSchema as d2, memberCampaignWithdrawalInputSchema as d3, memberListSchema as d4, memberPageSchema as d5, memberProgressSchema as d6, organizationDiscordServersSchema as d7, photoResultSchema as d8, pickupAllocationSchema as d9, questBudgetViewSchema as dA, questPresentationContentSchema as dB, questPresentationRequirementSchema as dC, questPresentationSchema as dD, questProfileSchema as dE, questSettingsInputSchema as dF, questStepActionSchema as dG, questStepSchema as dH, questSubmissionResultSchema as dI, questSubmissionSchema as dJ, questSubmissionUpdateSchema as dK, quizAnswersSchema as dL, quizEvidenceSchema as dM, referralAccountSchema as dN, referralArtifactSchema as dO, referralControlSchema as dP, referralDefinitionSchema as dQ, referralHistorySchema as dR, referralManagementSchema as dS, referralQualificationSchema as dT, referralRelationshipSchema as dU, referralRewardResolutionSchema as dV, referralSummarySchema as dW, referralSuspensionSchema as dX, releaseSchema as dY, removeGroupMemberSchema as dZ, reservationSchema as d_, pickupAvailabilitySchema as da, pickupCatalogSchema as db, pickupPolicySchema as dc, pickupSelectionSchema as dd, pointBalanceSchema as de, pointBalancesSchema as df, pointEntrySchema as dg, pointHistoryPageSchema as dh, pointHistoryQuerySchema as di, pointLedgerArtifactSchema as dj, pointLedgerPropertiesSchema as dk, pointLedgerReferenceSchema as dl, pointLedgerSchema as dm, pointsAccountSchema as dn, pointsEntrySchema as dp, pointsMutationSchema as dq, pointsResultSchema as dr, pointsRewardSchema as ds, projectGroupKey as dt, projectGroupSchema as du, projectIntegrationSchema as dv, publishedLeaderboardSchema as dw, publishedReferralSchema as dx, publishedReleaseSchema as dy, questAvailabilitySchema as dz, type CampaignEnrollment as e, retryCooldownPolicy as e0, reviewItemSchema as e1, reviewListSchema as e2, reviewModeSchema as e3, reviewPageSchema as e4, rewardBundleSchema as e5, rewardEntrySchema as e6, rewardKey as e7, settlementPaymentSchema as e8, signInAccountSchema as e9, signInProviderInputSchema as ea, signInProviderOptionSchema as eb, signInProviderSchema as ec, snapshotSchema as ed, staffDecisionSchema as ee, stockItemSchema as ef, stockSchema as eg, storedQuestDescriptionSchema as eh, storedReviewModeSchema as ei, submissionEvidenceSchema as ej, templateSchema as ek, textResultSchema as el, textReviewInputSchema as em, tierRewardSchema as en, tieredRewardDefinitionSchema as eo, tieredRewardReferenceSchema as ep, updateGroupSchema as eq, type SolanaTransactionSubmission as er, maxSolanaActionReference as es, parseSolanaActionMemo as et, solanaActionMemo as eu, solanaSignatureSchema as ev, solanaTransactionSubmissionSchema as ew, takesSolanaTransaction as ex, type CampaignEnrollmentInput as f, type CampaignView as g, type CampaignWithdrawalInput as h, type EvaluatorProgress as i, type KnownPointEntryKind as j, type KnownSignInAccountStatus as k, type KnownSignInProvider as l, type LeaderboardHistoryPage as m, type LeaderboardHistoryQuery as n, type LeaderboardPage as o, type LeaderboardPlacement as p, type LeaderboardQuery as q, type MemberCampaignWithdrawalInput as r, type MemberProgress as s, type PointBalances as t, type PointEntry as u, PointEntryKind as v, type PointHistoryPage as w, type PointHistoryQuery as x, type PointLedgerReference as y, type ProjectGroup as z };

package/dist/{attempt-captures-BqPggxTU.d.ts → attempt-captures-DMNFMYFb.d.ts}

@@ -1,4 +1,5 @@
-import { O as OpenIdentityKind } from './tracker-data-Bl-qPIvZ.js';
+import { V as KnownAttemptActionKind } from './accounts-DnpKoJCo.js';
+import { O as OpenIdentityKind } from './tracker-data-CAK942sx.js';
 import * as z from 'zod';
 
 /** One capability call of the captured evaluation run, as Relay stored it. */
@@ -143,6 +144,13 @@ declare const attemptCaptureSchema: z.ZodObject<{
             }, z.core.$strip>;
             enrolledAt: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        action: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            kind: z.ZodType<KnownAttemptActionKind | (string & {})>;
+            chain: z.ZodString;
+            signature: z.ZodString;
+            wallet: z.ZodString;
+            reference: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
         eligibleAt: z.ZodNumber;
         calendar: z.ZodObject<{
             segments: z.ZodArray<z.ZodObject<{