@domino-sdk/relay 1.56.0 → 1.60.0

package/dist/authoring.js

@@ -6,11 +6,9 @@ import {
   defineDashboard,
   tiktokVideoBodySchema,
   tiktokVideoMetrics,
-  tiktokVideosNamespace,
   youtubeShortBodySchema,
-  youtubeShortMetrics,
-  youtubeShortsNamespace
-} from "./chunk-ULQU7KC4.js";
+  youtubeShortMetrics
+} from "./chunk-N3LJ6GFK.js";
 import {
   CapabilityError,
   capabilityErrorCodes
@@ -19,7 +17,7 @@ import {
   sourceDataSchema,
   sourceRoles,
   validateQuestShape
-} from "./chunk-H2MD6E7Z.js";
+} from "./chunk-VWMIA2TT.js";
 import {
   badgeDeclarationSchema,
   defineOffer,
@@ -28,13 +26,13 @@ import {
   engagementScoreSchema,
   leaderboardAuthoringSchema,
   referralAuthoringSchema
-} from "./chunk-BJYMTCWG.js";
+} from "./chunk-MJEJQH5A.js";
 import {
-  pointLedgerDeclarationSchema,
-  telegramReactionDataSchema,
-  telegramReactionsNamespace
-} from "./chunk-VSHV7FEA.js";
+  pointLedgerDeclarationSchema
+} from "./chunk-YNW2ZUUP.js";
 import {
+  announcementSchema,
+  authorBudgetSchema,
   authoringKey,
   badgeReward,
   balanceAtLeast,
@@ -53,6 +51,7 @@ import {
   defaultTriggerMode,
   defineCampaign,
   defineGroup,
+  discordAnnouncementSchema,
   discordMessagesSourceSchema,
   discordReactionsSourceSchema,
   discordRewardSchema,
@@ -64,9 +63,22 @@ import {
   isAmount,
   isBalanceChain,
   isBoundSetting,
+  isContractCall,
+  isContractEvent,
   isEvmChainId,
+  isNftCollection,
+  isSolanaProgram,
   ledgerKey,
   ledgerSettingSchema,
+  maxWalletEventLogs,
+  maxWalletEventLookback,
+  maxWalletTransactionLookback,
+  maxWalletTransactions,
+  parseAnnouncementTemplate,
+  parseContractCall,
+  parseContractEvent,
+  parseContractFunction,
+  parseNftCollection,
   parseSettings,
   pointsRewardSchema,
   questDescriptionSchema,
@@ -81,23 +93,34 @@ import {
   settingFieldSchema,
   settingInstant,
   settingResourceId,
+  solanaAddressSchema,
+  solanaMainnet,
   sourceContent,
   sourceIdentities,
   streakPolicySchema,
+  telegramAnnouncementSchema,
+  telegramMessageDataSchema,
+  telegramMessagesNamespace,
+  telegramReactionDataSchema,
+  telegramReactionsNamespace,
   textOptionsSchema,
   textSettingSchema,
   tierRewardSchema,
   tieredRewardDefinitionSchema,
+  tiktokVideosNamespace,
   trackerDataIssue,
   trackerDataSchema,
   trackerDefinitionSchema,
   trackerTriggerContextSchema,
   trackerTriggerPolicySchema,
   urlOptionsSchema,
+  walletBalanceSampleSchema,
+  walletBalancesNamespace,
   whereSchemaIssue,
   whereSettings,
-  xSearchSourceSchema
-} from "./chunk-BHHUSBSD.js";
+  xSearchSourceSchema,
+  youtubeShortsNamespace
+} from "./chunk-GBSDAD3N.js";
 
 // src/builders.ts
 import * as z from "zod";
@@ -274,6 +297,19 @@ var discord = {
     action: "grant-role",
     roleId
   }),
+  /**
+   * An announcement Domino's bot posts in a channel of the project's Discord server when a
+   * completion pays, such as `"{beneficiary} got +{points} XP from {author}"`. Placeholders are
+   * `announcementPlaceholders`; `{beneficiary}` and `{author}` mention linked Discord accounts.
+   * Pass it in the quest's `announcements`, and declare the `discord` integration.
+   */
+  postMessage(options) {
+    return discordAnnouncementSchema.parse({
+      provider: "discord",
+      action: "post-message",
+      ...options
+    });
+  },
   messages,
   reactions,
   roles(options = {}) {
@@ -283,15 +319,40 @@ var discord = {
       assignable: options.assignable ?? false
     });
   },
+  /**
+   * A channel of the project's Discord server, for a resource setting. With `postable: true`,
+   * Console lists channels Domino's bot cannot post in as unavailable, as an announcement's
+   * channel needs.
+   */
   channels(options = {}) {
     return resourceSourceSchema.parse({
       provider: "discord",
       resource: "channel",
-      types: options.types ?? ["text", "announcement"]
+      types: options.types ?? ["text", "announcement"],
+      ...options.postable ? { postable: true } : {}
     });
   }
 };
 var telegram = {
+  /**
+   * An announcement Domino's bot posts in a connected chat when a completion pays, such as
+   * `"{beneficiary} got +{points} XP from {author}"`. Name the chat with `settings.telegramChat()`.
+   * Placeholders are `announcementPlaceholders`; `{beneficiary}` and `{author}` mention Telegram
+   * accounts. Pass it in the quest's `announcements`.
+   */
+  postMessage(options) {
+    return telegramAnnouncementSchema.parse({
+      provider: "telegram",
+      action: "post-message",
+      ...options
+    });
+  },
+  messages() {
+    return customSource(telegramMessagesNamespace, {
+      identities: ["member"],
+      data: telegramMessageDataSchema
+    });
+  },
   reactions() {
     return customSource(telegramReactionsNamespace, {
       identities: ["member"],
@@ -322,6 +383,50 @@ var tiktok = {
     });
   }
 };
+function walletBalanceSource(query) {
+  const { chain, token } = query;
+  const given = token === void 0 ? null : token;
+  if (given !== null && typeof given !== "string") {
+    throw new Error("wallet.balances() takes the token as a string");
+  }
+  if (chain === "solana" || chain === solanaMainnet) {
+    if (given !== null && !solanaAddressSchema.safeParse(given).success) {
+      throw new Error(
+        "wallet.balances() on Solana takes an SPL or Token-2022 mint address (base58)"
+      );
+    }
+    return { chain: solanaMainnet, token: given };
+  }
+  if (typeof chain === "string" && isEvmChainId(chain)) {
+    if (given !== null && !/^0x[0-9a-fA-F]{40}$/.test(given)) {
+      throw new Error(
+        "wallet.balances() on an EVM chain takes an ERC-20 contract address: 0x and 40 hex digits"
+      );
+    }
+    return { chain, token: given };
+  }
+  if (typeof chain === "string" && /^cosmos:[-_a-zA-Z0-9]{1,32}$/.test(chain)) {
+    if (given === null || !cosmosDenomSchema.safeParse(given).success) {
+      throw new Error(
+        "wallet.balances() on a Cosmos chain takes a bank denomination such as uatom"
+      );
+    }
+    return { chain, token: given };
+  }
+  throw new Error(
+    'wallet.balances() reads "solana", an EVM chain such as "eip155:8453" or a Cosmos network such as "cosmos:cosmoshub-4"'
+  );
+}
+var wallet = {
+  balances(query) {
+    const balance = walletBalanceSource(query);
+    const source = customSource(walletBalancesNamespace, {
+      identities: ["wallet"],
+      data: walletBalanceSampleSchema
+    });
+    return customSourceSchema.parse({ ...source, balance });
+  }
+};
 var pointLedgers = () => ({
   provider: "domino",
   resource: "point-ledger"
@@ -451,6 +556,114 @@ var settings = {
       textSettingSchema(field).transform((value) => value).default(field.default).meta(field)
     );
   },
+  /**
+   * An NFT collection `ctx.wallet.nfts()` reads, as a CAIP-19 asset type: an EVM chain, the
+   * standard and the contract, such as `"eip155:1/erc721:0x…"`, or `"eip155:8453/erc1155:0x…/1"` for
+   * one ERC-1155 token ID; or a Metaplex collection NFT's mint on Solana mainnet,
+   * `"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/nft:<mint>"`. Relay checks it when the collection is
+   * published or edited: an EVM chain must be one `ctx.wallet.balance()` reads and the contract
+   * must report the standard through ERC-165 `supportsInterface`; a Solana mint must be a Metaplex
+   * collection NFT. Typed as the query's collection, so it passes to
+   * `ctx.wallet.nfts({ collection })` as it is.
+   */
+  nft(options) {
+    if (!isNftCollection(options.default)) {
+      throw new Error(
+        `settings.nft() takes an NFT collection such as "eip155:1/erc721:0x\u2026" as its default, not "${options.default}"`
+      );
+    }
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: 1,
+      maxLength: 200,
+      multiline: false,
+      picker: "nft"
+    };
+    return setting(
+      "text",
+      textSettingSchema(field).transform((value) => value).default(field.default).meta(field)
+    );
+  },
+  /**
+   * A contract function `ctx.wallet.call()` reads: the contract's CAIP-10 account ID on an EVM
+   * chain, a space, and the function's human-readable signature, such as
+   * `"eip155:8453:0x… function stakedOf(address) view returns (uint256)"`. Only `view` and `pure`
+   * functions with elementary parameters that return one `uint`, `int`, `bool` or `address` are
+   * accepted; publication and Console edits also check that Relay reads the chain. Typed as the
+   * query's call, so it passes to `ctx.wallet.call({ call })` as it is.
+   */
+  contractCall(options) {
+    if (!isContractCall(options.default)) {
+      throw new Error(
+        `settings.contractCall() takes a contract call such as "eip155:8453:0x\u2026 function stakedOf(address) view returns (uint256)" as its default, not "${options.default}"`
+      );
+    }
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: 1,
+      maxLength: 400,
+      multiline: false,
+      picker: "contract-call"
+    };
+    return setting(
+      "text",
+      textSettingSchema(field).transform((value) => value).default(field.default).meta(field)
+    );
+  },
+  /**
+   * An EVM contract event `ctx.wallet.events()` reads: the contract as a CAIP-10 account ID and
+   * the event's Solidity signature, with argument names and `indexed` markers, such as
+   * `"eip155:8453:0x… Transfer(address indexed from, address indexed to, uint256 value)"`. The event
+   * needs an indexed `address` argument, the one matched against the member's wallets. Relay checks
+   * it when the event is published or edited: the chain must be one `ctx.wallet.balance()` reads
+   * and report a finalized or safe block, and the address must hold a contract. Typed as the query's
+   * event, so it passes to `ctx.wallet.events({ event })` as it is.
+   */
+  contractEvent(options) {
+    if (!isContractEvent(options.default)) {
+      throw new Error(
+        `settings.contractEvent() takes a contract event such as "eip155:1:0x\u2026 Transfer(address indexed from, address indexed to, uint256 value)" as its default, not "${options.default}"`
+      );
+    }
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: 1,
+      maxLength: 1e3,
+      multiline: false,
+      picker: "contract-event"
+    };
+    return setting(
+      "text",
+      textSettingSchema(field).transform((value) => value).default(field.default).meta(field)
+    );
+  },
+  /**
+   * A Solana mainnet program `ctx.wallet.transactions()` reads: its base58 address, such as
+   * Jupiter's `"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"`. Relay checks it when it is published
+   * or edited: the account must exist and be an executable program.
+   */
+  solanaProgram(options) {
+    if (!isSolanaProgram(options.default)) {
+      throw new Error(
+        `settings.solanaProgram() takes a Solana program address such as "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4" as its default, not "${options.default}"`
+      );
+    }
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: 32,
+      maxLength: 44,
+      multiline: false,
+      picker: "solana-program"
+    };
+    return setting(
+      "text",
+      textSettingSchema(field).transform((value) => value).default(field.default).meta(field)
+    );
+  },
   integer(options) {
     return setting(
       "integer",
@@ -478,6 +691,37 @@ var settings = {
 // src/authoring.ts
 import { z as z2 } from "zod";
 import * as z3 from "zod";
+
+// src/solana-transactions.ts
+function delta(tx, mint) {
+  const change = tx.balanceChanges.find((entry) => entry.mint === mint);
+  return change ? BigInt(change.delta) : 0n;
+}
+function received(tx, mint) {
+  const change = delta(tx, mint);
+  return change > 0n ? change.toString() : "0";
+}
+function spent(tx, mint) {
+  const change = delta(tx, mint);
+  return change < 0n ? (-change).toString() : "0";
+}
+function swapped(tx, options = {}) {
+  const up = tx.balanceChanges.filter((change) => BigInt(change.delta) > 0n);
+  const down = tx.balanceChanges.filter((change) => BigInt(change.delta) < 0n);
+  return up.some(
+    (gained) => (options.into === void 0 || gained.mint === options.into) && down.some(
+      (gave) => gave.mint !== gained.mint && (options.from === void 0 || gave.mint === options.from)
+    )
+  );
+}
+function invoked(tx, program) {
+  return tx.programs.includes(program);
+}
+function instruction(tx, name) {
+  return tx.instructions?.find((entry) => entry.name === name)?.args ?? null;
+}
+
+// src/authoring.ts
 var badge = (definition) => badgeReward(definition.key, definition.name);
 var groupMembership = (group) => groupReward(group.key, group.title);
 var points = (ledger, amount) => pointsRewardSchema.parse({
@@ -594,14 +838,17 @@ function content(input) {
   }
   return trackerTrigger({ ...input, content: true }, "content");
 }
-var budget = (definition) => {
+function defineBudget(definition) {
   const { key: _, cost, ...properties } = definition;
-  return budgetSchema.parse({
+  const parsed = {
     ...properties,
     id: authoringKey(definition),
     cost: typeof cost === "number" ? cost : { balance: ledgerKey(cost.ledger) }
-  });
-};
+  };
+  return properties.scope === "author" ? authorBudgetSchema.parse(parsed) : budgetSchema.parse(parsed);
+}
+var budget = defineBudget;
+var authorBudgets = (budgets = []) => budgets.filter((value) => value.scope === "author");
 var keyed = (key) => ({
   kind: "keyed",
   key
@@ -721,11 +968,13 @@ function questBuilder(template) {
         "A quest needs a completion, such as once(), keyed(...), streak(...) or progress(...)"
       );
     }
+    const author = authorBudgets(definition.budgets);
     validateQuestShape(
       {
         trigger: definition.trigger,
         completion: completion ?? { kind: "keyed" },
         requires: definition.requires ?? [],
+        authorBudgets: author,
         performance: definition.performance ? contentPerformancePolicySchema.parse({
           metrics: definition.performance.metrics,
           maxAgeMs: definition.performance.maxAgeMs
@@ -785,10 +1034,33 @@ function questBuilder(template) {
       const rewards = rewardBundleSchema.parse(
         typeof definition.rewards === "function" ? definition.rewards({ settings: settings2 }) : definition.rewards
       );
+      const announcements = z3.array(announcementSchema).max(3, "A quest posts at most three announcements").parse(
+        (typeof definition.announcements === "function" ? definition.announcements({ settings: settings2 }) : definition.announcements) ?? []
+      );
+      const trackerTrigger3 = definition.trigger.kind === "automatic" && definition.trigger.tracker !== void 0;
+      for (const announcement of announcements) {
+        const parsed = parseAnnouncementTemplate(announcement.text);
+        const usesAuthor = "segments" in parsed && parsed.segments.some(
+          (segment) => segment.kind === "placeholder" && segment.name === "author"
+        );
+        if (!trackerTrigger3 && usesAuthor) {
+          throw new Error(
+            "An announcement names {author} only on a quest with an automatic tracker trigger"
+          );
+        }
+        if (!trackerTrigger3 && announcement.replyToTriggeringMessage) {
+          throw new Error(
+            "An announcement replies to the triggering message only on a quest with an automatic tracker trigger"
+          );
+        }
+      }
       const required = [
         ...rewards.flatMap(
           (reward) => reward.kind === "integration" ? [reward.provider] : []
         ),
+        ...announcements.flatMap(
+          (announcement) => announcement.provider === "discord" ? ["discord"] : []
+        ),
         ...Object.values(fields).flatMap(
           (field) => field.kind === "resource" && field.source.provider !== "domino" ? [field.source.provider] : []
         )
@@ -806,6 +1078,7 @@ function questBuilder(template) {
         fields,
         values,
         rewards,
+        ...announcements.length ? { announcements } : {},
         humanReview: definition.review?.({ settings: settings2 })?.enabled ?? true,
         trigger: definition.trigger,
         ...definition.performance ? {
@@ -824,7 +1097,10 @@ function questBuilder(template) {
         } : completion.kind === "streak" ? completion : { kind: completion.kind },
         visibility: definition.visibility ?? "visible",
         profile: definition.profile ?? { visible: false },
-        budgets: definition.budgets ?? [],
+        budgets: (definition.budgets ?? []).filter(
+          (value) => value.scope !== "author"
+        ),
+        ...author.length ? { authorBudgets: author } : {},
         requires: definition.requires ?? [],
         ...definition.campaign ? { campaign: definition.campaign } : {},
         ...definition.availability ? { availability: definition.availability } : {},
@@ -985,24 +1261,42 @@ export {
   formatUnits,
   groupMembership,
   inGroup,
+  instruction,
+  invoked,
+  isContractCall,
+  isContractEvent,
   isEvmChainId,
+  isNftCollection,
+  isSolanaProgram,
   keyed,
   manual,
+  maxWalletEventLogs,
+  maxWalletEventLookback,
+  maxWalletTransactionLookback,
+  maxWalletTransactions,
   once,
+  parseContractCall,
+  parseContractEvent,
+  parseContractFunction,
+  parseNftCollection,
   parseUnits,
   pointLedgers,
   points,
   progress,
   questCompleted,
+  received,
   rolling,
   settings,
+  spent,
   staffHandover,
   streak,
+  swapped,
   telegram,
   tiktok,
   trackerDataSchema,
   trackerTriggerContextSchema,
   untracked,
+  wallet,
   x,
   youtube,
   z2 as z

package/dist/{automatic-outcomes-DxW_v5Wc.d.ts → automatic-outcomes-Cmou89IS.d.ts}

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import { a as AttemptStatus } from './schema-C4m9RhCR.js';
+import { a as AttemptStatus } from './schema-CwbRkmlr.js';
 
 declare const collectionCodeSchema: z.ZodString;
 declare const collectionPassSchema: z.ZodObject<{

package/dist/avatar.d.ts

@@ -1,5 +1,4 @@
-import { L as LinkedWallet } from './wallet-Ac7OFpOr.js';
-import { P as ProfileAvatar } from './profiles-BoOK03cR.js';
+import { P as ProfileAvatar, L as LinkedWallet } from './wallet-DZWL7lJH.js';
 import 'zod';
 
 /**

package/dist/browser.d.ts

@@ -1,16 +1,24 @@
-import { o as SubmissionStore, f as RelayClientOptions, R as RelayClient } from './client-bX3oTpRu.js';
-export { C as CosmosChains, D as DiscoveredWallet, E as Eip1193Provider, a as EmailSignInOption, K as KeplrLike, O as OAuthSignInOption, S as SignInClient, b as SignInIcon, c as SignInMethods, d as SignInOption, e as SignInOptions, f as SignInUnavailable, g as SignInWallet, h as SolanaInjectedProvider, i as StandardWallet, j as StandardWalletAccount, T as TelegramSignInOption, W as WalletSignInOption, k as cosmosChainList, l as cosmosSigner, m as discoverCosmosWallets, n as discoverEvmWallets, o as discoverSignInWallets, p as discoverSolanaWallets, q as evmSigner, s as signInOptions, r as solanaSigner, t as telegramMiniAppInitData, w as walletStandardSolanaSigner } from './telegram-browser-Bh3i0HiH.js';
+import { o as SubmissionStore, f as RelayClientOptions, R as RelayClient } from './client-Cw1pB5sv.js';
+export { C as CosmosChains, D as DiscoveredWallet, E as Eip1193Provider, a as EmailSignInOption, K as KeplrLike, O as OAuthSignInOption, S as SignInClient, b as SignInIcon, c as SignInMethods, d as SignInOption, e as SignInOptions, f as SignInUnavailable, g as SignInWallet, h as SolanaInjectedProvider, i as StandardWallet, j as StandardWalletAccount, T as TelegramSignInOption, W as WalletSignInOption, k as cosmosChainList, l as cosmosSigner, m as discoverCosmosWallets, n as discoverEvmWallets, o as discoverSignInWallets, p as discoverSolanaWallets, q as evmSigner, s as signInOptions, r as solanaSigner, t as telegramMiniAppInitData, w as walletStandardSolanaSigner } from './telegram-browser-CTJh4Ro_.js';
 export { H as HostEnvironment, g as getHostEnvironment } from './host-environment-FN4zg3hw.js';
-import './schema-C4m9RhCR.js';
+import { M as MemberSummary } from './participant-activity-DHL8QYks.js';
+import './schema-CwbRkmlr.js';
 import 'zod';
-import './pages-BlLqB8ZQ.js';
-import './submission-input-wTiYGdgA.js';
-import './groups-DPE004_V.js';
+import './wallet-DZWL7lJH.js';
+import './pages-Bti7g5mX.js';
+import './submission-input-D9EGH_yb.js';
+import './groups-9Jm3peq3.js';
 import './action-DBzILFx9.js';
-import './participant-activity-iciCEs_8.js';
-import './accounts-DRPENuZe.js';
-import './profiles-BoOK03cR.js';
-import './wallet-Ac7OFpOr.js';
+import './accounts-DoabriBX.js';
+
+/**
+ * The member's time at the real instant `at` (default now), in epoch milliseconds: what an app
+ * compares campaign phases and quest dates against, so it shows what Relay judges on. Applies
+ * `me.clock.offsetMs` from `GET /v1/me`, which moves when the staging toolbar moves a test member's
+ * clock; read `/v1/me` again on `domino:test-state-changed`. Without `clock` (a Relay older than
+ * it) the member's time is real time.
+ */
+declare function memberTime(me: Pick<MemberSummary, "clock">, at?: number): number;
 
 /** Browser client with durable submission recovery; safe to construct during SSR. */
 declare function createBrowserRelayClient(options: RelayClientOptions): RelayClient;
@@ -22,4 +30,4 @@ declare function createBrowserRelayClient(options: RelayClientOptions): RelayCli
  */
 declare function browserSubmissionStore(): SubmissionStore;
 
-export { browserSubmissionStore, createBrowserRelayClient };
+export { browserSubmissionStore, createBrowserRelayClient, memberTime };

package/dist/browser.js

@@ -8,23 +8,24 @@ import {
   discoverSignInWallets,
   discoverSolanaWallets,
   evmSigner,
+  memberTime,
   signInOptions,
   solanaSigner,
   telegramMiniAppInitData,
   walletStandardSolanaSigner
-} from "./chunk-OTITLABX.js";
-import "./chunk-NK6EER33.js";
-import "./chunk-INSWI2VZ.js";
-import "./chunk-RBPMT53S.js";
-import "./chunk-BJYMTCWG.js";
-import "./chunk-VSHV7FEA.js";
+} from "./chunk-2FHNY52R.js";
+import "./chunk-VVRQQRMQ.js";
+import "./chunk-4OFH4BNX.js";
+import "./chunk-XQKUJL7H.js";
+import "./chunk-MJEJQH5A.js";
+import "./chunk-YNW2ZUUP.js";
 import {
   getHostEnvironment
 } from "./chunk-KDR2VAJP.js";
-import "./chunk-KBVH4XZC.js";
-import "./chunk-ABJ4G47X.js";
-import "./chunk-QNQNKIAA.js";
-import "./chunk-BHHUSBSD.js";
+import "./chunk-6ZG7WNYX.js";
+import "./chunk-N7YOS4ZU.js";
+import "./chunk-422J3QRW.js";
+import "./chunk-GBSDAD3N.js";
 export {
   browserSubmissionStore,
   cosmosChainList,
@@ -36,6 +37,7 @@ export {
   discoverSolanaWallets,
   evmSigner,
   getHostEnvironment,
+  memberTime,
   signInOptions,
   solanaSigner,
   telegramMiniAppInitData,

package/dist/{capability-error-DSd8EMQC.d.ts → capability-error-DufwG3G0.d.ts}

@@ -51,6 +51,26 @@ declare const budgetSchema: z.ZodObject<{
     }, z.core.$strict>]>;
 }, z.core.$strict>;
 type Budget = z.infer<typeof budgetSchema>;
+/**
+ * A budget counted per tracker record author: the account that caused the record, such as a
+ * reaction's reactor, whether or not it belongs to a member. It caps what one person gives when a
+ * quest pays someone else. Only quests with a tracker trigger take one, in their `authorBudgets`.
+ */
+declare const authorBudgetSchema: z.ZodObject<{
+    id: z.ZodString;
+    period: z.ZodEnum<{
+        lifetime: "lifetime";
+        day: "day";
+        week: "week";
+        month: "month";
+    }>;
+    limit: z.ZodNumber;
+    cost: z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+        balance: z.ZodString;
+    }, z.core.$strict>]>;
+    scope: z.ZodLiteral<"author">;
+}, z.core.$strict>;
+type AuthorBudget = z.infer<typeof authorBudgetSchema>;
 /**
  * One of the member's accepted, unrevoked quest completions, as `ctx.member.completions()` reads
  * it. `quest` is the quest's key and `key` the completion key. `completedAt` is when it was
@@ -100,12 +120,6 @@ type CapabilityErrorCode = KnownCapabilityErrorCode | (string & {});
 declare const capabilityFailureSchema: z.ZodObject<{
     code: z.ZodString;
     message: z.ZodString;
-    /**
-     * True when Relay retries the attempt if the error reaches it uncaught, and calls the provider
-     * again. A failure that is not retryable is captured (or follows from the attempt's pinned
-     * inputs), so every run of the attempt sees it again. A retryable failure that quest code
-     * handles and moves past is final for the attempt; one that escapes the evaluation is retried.
-     */
     retryable: z.ZodBoolean;
 }, z.core.$loose>;
 type CapabilityFailure = z.infer<typeof capabilityFailureSchema>;
@@ -142,4 +156,4 @@ declare class CapabilityError extends Error {
     static from(failure: CapabilityFailure): CapabilityError;
 }
 
-export { type Budget as B, CapabilityError as C, type KnownCapabilityErrorCode as K, type MemberCompletion as M, type CapabilityErrorCode as a, type CapabilityFailure as b, capabilityErrorCodes as c, budgetSchema as d, capabilityFailureSchema as e, completionKeySchema as f, completionPolicySchema as g, memberCompletionSchema as h, maxMemberCompletions as m };
+export { type AuthorBudget as A, type Budget as B, CapabilityError as C, type KnownCapabilityErrorCode as K, type MemberCompletion as M, type CapabilityErrorCode as a, type CapabilityFailure as b, capabilityErrorCodes as c, authorBudgetSchema as d, budgetSchema as e, capabilityFailureSchema as f, completionKeySchema as g, completionPolicySchema as h, maxMemberCompletions as i, memberCompletionSchema as m };

package/dist/{chunk-OTITLABX.js → chunk-2FHNY52R.js}

@@ -1,12 +1,12 @@
 import {
   createRelayClient
-} from "./chunk-NK6EER33.js";
+} from "./chunk-VVRQQRMQ.js";
 import {
   RelayErrorCode,
   asRelayError,
   clientError,
   cosmosChain
-} from "./chunk-BHHUSBSD.js";
+} from "./chunk-GBSDAD3N.js";
 
 // src/base58.ts
 var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -520,6 +520,11 @@ function telegramMiniAppInitData() {
   return new URLSearchParams(hash.replace(/^#/, "")).get("tgWebAppData") || null;
 }
 
+// src/member-time.ts
+function memberTime(me, at = Date.now()) {
+  return at + (me.clock?.offsetMs ?? 0);
+}
+
 // src/browser.ts
 function createBrowserRelayClient(options) {
   return createRelayClient({
@@ -699,6 +704,7 @@ export {
   readSignInMethods,
   signInOptions,
   telegramMiniAppInitData,
+  memberTime,
   createBrowserRelayClient,
   browserSubmissionStore
 };