@domino-sdk/relay 1.0.0-next.8 → 1.0.0

package/dist/{chunk-V7EZUZ3Z.js → chunk-36HTX2BM.js}

@@ -1,59 +1,104 @@
 import {
+  RequestError,
+  isRequestError
+} from "./chunk-NPGENI7K.js";
+import {
+  authoringIdentityShape,
+  calendarPeriodSchema,
   contentMetricSchema,
   contentMetricsSchema,
   identifier,
   pageCursorSchema,
   pointsRewardSchema,
+  refuseWindowTimeZone,
+  resourceHandle,
+  rewardKey,
   tierRewardSchema
-} from "./chunk-VARGF4JS.js";
+} from "./chunk-JON5SESL.js";
 
-// src/authoring-identity.ts
+// src/point-ledgers.ts
 import { z } from "zod";
-var authoringIdentityShape = {
-  key: identifier.optional(),
-  id: identifier.optional()
+var pointLedgerPropertiesSchema = z.object({
+  name: z.string().trim().min(1).max(120),
+  description: z.string().trim().max(1e3).default("")
+}).strict();
+var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
+var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
+  id: identifier
+});
+var managedPointLedgerSchema = pointLedgerSchema.extend({
+  archivedAt: z.number().int().nonnegative().nullable()
+});
+var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
+var pointLedgerArtifactSchema = z.union([
+  pointLedgerDeclarationSchema,
+  z.object({ code: z.string().min(1).max(2e6) }).strict()
+]);
+var pointLedgerReferenceSchema = z.object({
+  id: identifier,
+  key: identifier.nullable(),
+  name: z.string()
+});
+var points = z.number().int().safe();
+var pointBalanceSchema = z.object({
+  ledger: pointLedgerReferenceSchema,
+  balance: points,
+  available: points
+});
+var pointBalancesSchema = z.object({
+  items: z.array(pointBalanceSchema)
+});
+var PointEntryKind = {
+  /** Points a quest completion, an engagement settlement or an operator awarded. */
+  Award: "award",
+  /** Points the member spent. */
+  Spend: "spend",
+  /** A correction in either direction, by an operator or a referral payout. */
+  Adjust: "adjust",
+  /** Undoes part or all of an award or a positive adjustment (`reverses`). */
+  Reverse: "reverse"
 };
-function validateAuthoringIdentity(value, ctx) {
-  if (!value.key && !value.id) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["key"],
-      message: "Provide an authoring key. Legacy id is also accepted."
-    });
-  }
-  if (value.key && value.id && value.key !== value.id) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["key"],
-      message: "id and key must match. Keep the existing authoring name to preserve identity."
-    });
-  }
-}
-function normalizeAuthoringIdentity(value) {
-  const { id, key, ...properties } = value;
-  return { ...properties, key: identifier.parse(key ?? id) };
-}
-var identitySchema = z.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
-var authoringKey = (input) => identitySchema.parse(input).key;
+var pointEntryKindSchema = z.string().min(1).max(64);
+var pointEntrySchema = z.object({
+  id: identifier,
+  amount: points,
+  kind: pointEntryKindSchema,
+  /** When the entry took effect, in epoch milliseconds. A reversal keeps its source's. */
+  at: points.nonnegative(),
+  quest: identifier.nullable(),
+  reverses: identifier.nullable()
+});
+var pointHistoryQuerySchema = z.strictObject({
+  ledger: identifier,
+  cursor: pageCursorSchema.optional()
+});
+var pointHistoryPageSchema = z.object({
+  items: z.array(pointEntrySchema),
+  nextCursor: pageCursorSchema.nullable()
+});
 
 // src/engagement.ts
 import { z as z2 } from "zod";
 var amount = z2.number().int().safe().nonnegative();
+var engagementBudgetSchema = z2.strictObject({
+  scope: z2.enum(["member", "project"]),
+  period: calendarPeriodSchema,
+  limit: amount
+});
 var engagementDefinitionSchema = z2.strictObject({
   key: identifier,
   qualifiedBy: identifier,
   balance: identifier,
-  metrics: z2.array(contentMetricSchema).min(1).max(6).refine(
+  metrics: z2.array(contentMetricSchema).min(1).max(10).refine(
     (metrics) => new Set(metrics).size === metrics.length,
     "Metrics must be unique"
   ),
   baseline: z2.literal("historical"),
   maxAgeMs: z2.number().int().positive().max(864e5).default(36e5),
-  budget: z2.strictObject({
-    projectDaily: amount.optional(),
-    memberDaily: amount.optional(),
-    projectLifetime: amount.optional()
-  }).default({})
+  budgets: z2.array(engagementBudgetSchema).max(8).default([]).refine(
+    (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
+    "Give each scope and period one budget"
+  )
 });
 var engagementScoreInputSchema = z2.strictObject({
   metrics: contentMetricsSchema,
@@ -174,32 +219,6 @@ var engagementDeploymentEntrySchema = z2.discriminatedUnion("kind", [
   })
 ]);
 
-// src/request-error.ts
-var requestErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RequestError");
-function isRequestError(value) {
-  return typeof value === "object" && value !== null && value[requestErrorBrand] === true;
-}
-var RequestError = class extends Error {
-  name = "RequestError";
-  [requestErrorBrand] = true;
-  kind;
-  uncertain;
-  status;
-  code;
-  operationId;
-  /** `replay` when there is an `operationId`, else `reconcile`; only when `uncertain`. */
-  recovery;
-  constructor(message, details) {
-    super(message, details.cause === void 0 ? {} : { cause: details.cause });
-    this.kind = details.kind;
-    this.uncertain = details.uncertain ?? false;
-    this.status = details.status;
-    this.code = details.code;
-    this.operationId = details.operationId;
-    this.recovery = this.uncertain ? details.operationId ? "replay" : "reconcile" : void 0;
-  }
-};
-
 // src/errors.ts
 import { z as z3 } from "zod";
 var RelayErrorCode = {
@@ -221,18 +240,45 @@ var RelayErrorCode = {
   NotFound: "not-found",
   /** The quest has no failed attempt the member can retry. */
   RetryUnavailable: "retry-unavailable",
-  /** Durable submission storage is missing, blocked or unreadable. */
+  /**
+   * Durable submission storage is missing, blocked or unreadable. Nothing was lost: call the
+   * handle's `status()` or `resume()` again once storage is available.
+   */
   SubmissionStorage: "submission-storage",
+  /** Browser storage is full, so submission progress was not saved. Free space, then resume. */
+  SubmissionStorageQuota: "submission-storage-quota",
   /** The saved submission is in a state that does not allow this action. */
   SubmissionConflict: "submission-conflict",
   /** The quest changed since the member saw it; review it before submitting again. */
   QuestUpdated: "quest-updated",
+  /** Wait for the deferred attempt before submitting another action. */
+  AttemptPending: "attempt-pending",
   /** The quiz changed since the member answered it. */
   StaleQuiz: "stale-quiz",
   /** Relay refused the submitted evidence. */
   InvalidSubmission: "invalid-submission",
   /** A page cursor Relay cannot read; start again from the first page. */
   InvalidCursor: "invalid-cursor",
+  /** No point ledger in the project has the key or ID the call named. */
+  PointLedgerNotFound: "point-ledger-not-found",
+  /** The member has not joined this project, so it holds no points here. */
+  NotJoined: "not-joined",
+  /** The quest or campaign is not open at this time. */
+  OutsideWindow: "outside-window",
+  /** The signed-in member must enroll in the campaign first. */
+  EnrollmentRequired: "enrollment-required",
+  /** The quest's current reward budget has no remaining capacity. */
+  BudgetExhausted: "budget-exhausted",
+  /** No published offer has the key or ID the call named. */
+  OfferNotFound: "offer-not-found",
+  /** The operator paused this offer. */
+  OfferPaused: "offer-paused",
+  /** This member has already used the offer's allowed number of redemptions. */
+  OfferLimitReached: "offer-limit-reached",
+  /** No declared units remain. */
+  OfferOutOfStock: "offer-out-of-stock",
+  /** The participant's available point balance is below the offer price. */
+  InsufficientPoints: "insufficient-points",
   /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
   WalletSigner: "wallet-signer"
 };
@@ -243,13 +289,22 @@ function isRelayError(value) {
 var RelayError = class extends RequestError {
   name = "RelayError";
   [relayErrorBrand] = true;
-  /** Prerequisite quests the member has not completed, when Relay refused for that reason. */
+  /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
   missing;
   constructor(message, details) {
     super(message, details);
     this.missing = details.missing ?? [];
   }
 };
+function asRelayError(cause, fallback = "Request failed") {
+  if (isRelayError(cause)) {
+    return cause;
+  }
+  return new RelayError(
+    cause instanceof Error && cause.message ? cause.message : fallback,
+    { kind: "client", cause }
+  );
+}
 function clientError(message, code, details = {}) {
   return new RelayError(message, { ...details, kind: "client", code });
 }
@@ -409,45 +464,94 @@ var leaderboardWindowSchema = z5.discriminatedUnion("kind", [
   z5.object({ kind: z5.literal("all-time") }).strict(),
   z5.object({ kind: z5.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
   z5.object({ kind: z5.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  // Not strict: boards published while a calendar window named its own `timeZone` keep reading,
+  // and the field drops on parse. The authoring schema refuses it.
   z5.object({
     kind: z5.literal("calendar"),
-    period: z5.enum(["day", "week", "month"]),
-    timeZone: z5.string().min(1).max(100).refine((zone) => {
-      try {
-        new Intl.DateTimeFormat("en", { timeZone: zone });
-        return true;
-      } catch {
-        return false;
-      }
-    }, "Use an IANA timezone")
-  }).strict()
+    /** The current day, week (ISO, starting on Monday) or month of the project calendar. */
+    period: calendarPeriodSchema.exclude(["lifetime"])
+  })
 ]);
 var periodScore = {
   window: leaderboardWindowSchema.default({ kind: "all-time" }),
   quests: z5.array(identifier).min(1).max(100).optional()
 };
-var leaderboardDefinitionSchema = z5.object({
+var scoreSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("balance") }).strict(),
+  z5.object({ kind: z5.literal("earned"), ...periodScore }).strict(),
+  z5.object({
+    kind: z5.literal("net"),
+    window: leaderboardWindowSchema.default({ kind: "all-time" })
+  }).strict()
+]).default({ kind: "balance" });
+var leaderboardPrizeRewardSchema = z5.union([
+  pointsRewardSchema,
+  tierRewardSchema
+]);
+var leaderboardPrizeSchema = z5.object({
+  ranks: z5.tuple([integer.positive(), integer.positive()]).refine(([first, last]) => last >= first, {
+    message: "Prize rank range must end at or after it starts"
+  }),
+  rewards: z5.array(leaderboardPrizeRewardSchema).min(1).max(20)
+}).strict();
+var leaderboardSettlementPolicySchema = z5.object({
+  at: z5.literal("window-end"),
+  ties: z5.enum(["shared", "earliest"]),
+  prizes: z5.array(leaderboardPrizeSchema).min(1).max(50)
+}).strict().superRefine((policy, context) => {
+  for (const [index, prize] of policy.prizes.entries()) {
+    const keys = prize.rewards.map(rewardKey);
+    if (new Set(keys).size !== keys.length) {
+      context.addIssue({
+        code: "custom",
+        message: "A prize may grant each point ledger or tiered reward only once",
+        path: ["prizes", index, "rewards"]
+      });
+    }
+  }
+  for (let index = 1; index < policy.prizes.length; index++) {
+    const previous = policy.prizes[index - 1];
+    const current = policy.prizes[index];
+    if (current.ranks[0] <= previous.ranks[1]) {
+      context.addIssue({
+        code: "custom",
+        message: "Prize rank ranges must be ordered and must not overlap",
+        path: ["prizes", index, "ranks"]
+      });
+    }
+  }
+});
+var leaderboardDefinitionObject = z5.object({
   id: identifier,
   key: identifier.optional(),
   title: z5.string().trim().min(1).max(120),
   balance: identifier,
-  score: z5.discriminatedUnion("kind", [
-    z5.object({ kind: z5.literal("balance") }).strict(),
-    z5.object({ kind: z5.literal("earned"), ...periodScore }).strict(),
-    z5.object({
-      kind: z5.literal("net"),
-      window: leaderboardWindowSchema.default({ kind: "all-time" })
-    }).strict()
-  ]).default({ kind: "balance" }),
+  score: scoreSchema,
   access: z5.enum(["participants", "public"]).default("participants"),
-  group: identifier.optional()
+  group: identifier.optional(),
+  settle: leaderboardSettlementPolicySchema.optional()
 }).strict();
-var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var validateSettlementWindow = (definition, context) => {
+  if (definition.settle && (definition.score.kind === "balance" || !["fixed", "calendar"].includes(definition.score.window.kind))) {
+    context.addIssue({
+      code: "custom",
+      message: "Leaderboard prizes require an earned or net score with a fixed or calendar window",
+      path: ["settle"]
+    });
+  }
+};
+var leaderboardDefinitionSchema = leaderboardDefinitionObject.superRefine(validateSettlementWindow);
+var leaderboardAuthoringSchema = leaderboardDefinitionObject.omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  score: z5.preprocess(refuseWindowTimeZone, scoreSchema),
+  group: identifier.optional()
+}).strict().superRefine(validateSettlementWindow);
 var leaderboardArtifactSchema = z5.union([
   leaderboardAuthoringSchema,
   z5.object({ code: z5.string().min(1).max(2e6) }).strict()
 ]);
 var publishedLeaderboardSchema = z5.object({
+  archivedAt: z5.number().int().nonnegative().nullable().optional(),
   version: identifier,
   definition: leaderboardDefinitionSchema,
   publishedAt: timestamp,
@@ -465,11 +569,8 @@ var leaderboardRowSchema = z5.object({
   name: z5.string(),
   score: integer,
   rank: integer.positive(),
-  /**
-   * The member's profile, where the project shows profiles to this viewer and the member has not
-   * hidden theirs. Older servers omit it.
-   */
-  profile: profileSummarySchema.nullable().default(null)
+  /** The member's profile, where visible to this viewer and not hidden by the member. */
+  profile: profileSummarySchema.nullable()
 });
 var leaderboardPageSchema = z5.object({
   leaderboard: identifier,
@@ -574,6 +675,41 @@ var leaderboardGroupSchema = z5.object({
   included: z5.boolean(),
   reason: z5.string().trim().min(1).max(1e3)
 }).strict();
+var leaderboardSettlementStatusSchema = z5.enum(["pending", "approved"]);
+var leaderboardSettlementSummarySchema = z5.object({
+  id: identifier,
+  leaderboard: identifier,
+  version: identifier,
+  title: z5.string(),
+  period: z5.object({ start: timestamp, end: timestamp }),
+  ties: z5.enum(["shared", "earliest"]),
+  status: leaderboardSettlementStatusSchema,
+  total: integer.nonnegative(),
+  winners: integer.nonnegative(),
+  createdAt: timestamp,
+  approvedAt: timestamp.nullable(),
+  approvedBy: z5.string().nullable(),
+  approvalReason: z5.string().nullable()
+});
+var leaderboardSettlementRowSchema = z5.object({
+  member: identifier,
+  score: integer,
+  rank: integer.positive(),
+  position: integer.positive(),
+  scoredAt: timestamp,
+  prizes: z5.array(integer.nonnegative()),
+  completion: identifier.nullable(),
+  revokedAt: timestamp.nullable()
+});
+var leaderboardSettlementSchema = leaderboardSettlementSummarySchema.extend({
+  prizes: z5.array(leaderboardPrizeSchema),
+  excluded: z5.array(identifier),
+  rows: z5.array(leaderboardSettlementRowSchema)
+});
+var leaderboardSettlementApprovalSchema = z5.object({
+  actionId: identifier,
+  reason: z5.string().trim().min(1).max(500)
+}).strict();
 
 // src/referrals.ts
 import { z as z6 } from "zod";
@@ -620,18 +756,22 @@ var referralDefinitionSchema = z6.object({
     }
   }
 });
-var referralAuthoringSchema = z6.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
+var referralAuthoringSchema = z6.object(referralDefinitionSchema.shape).omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  inviterGroup: identifier.optional()
+}).strict().superRefine((value, ctx) => {
   for (const entries of [value.milestones, value.bonuses]) {
     if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
       ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
     }
   }
-}).transform(normalizeAuthoringIdentity);
+});
 var referralArtifactSchema = z6.union([
   referralAuthoringSchema,
   z6.object({ code: z6.string().min(1).max(2e6) }).strict()
 ]);
 var publishedReferralSchema = z6.object({
+  archivedAt: z6.number().int().nonnegative().nullable().optional(),
   version: identifier,
   definition: referralDefinitionSchema,
   publishedAt: amount2,
@@ -727,41 +867,96 @@ var referralManagementSchema = z6.object({
   next: amount2.nullable()
 });
 
-// src/wallet.ts
+// src/offers.ts
 import { z as z7 } from "zod";
-var solanaAddressSchema = z7.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletConnectionSchema = z7.object({
-  chain: z7.literal("solana"),
-  address: solanaAddressSchema,
-  verifiedAt: z7.number().int().nonnegative(),
-  revision: z7.number().int().positive()
-}).strict();
-var walletChallengeInputSchema = z7.object({
-  chain: z7.literal("solana"),
-  address: solanaAddressSchema
+var quantity = z7.number().int().safe().nonnegative();
+var offerPriceSchema = pointsRewardSchema.extend({
+  amount: z7.number().int().positive().max(1e4)
+});
+var offerLimitSchema = z7.object({ perMember: z7.number().int().positive().max(1e4) }).strict();
+var offerDefinitionSchema = z7.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z7.string().trim().min(1).max(120),
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  stock: quantity.max(1e6),
+  limit: offerLimitSchema.default({ perMember: 1 }),
+  enabled: z7.boolean().default(true)
 }).strict();
-var walletChallengeSchema = walletChallengeInputSchema.extend({
-  id: z7.string().uuid(),
-  message: z7.string(),
-  expiresAt: z7.number()
-});
-var walletProofSchema = z7.object({
-  challenge: z7.string().uuid(),
-  signature: z7.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
+var offerAuthoringSchema = offerDefinitionSchema.omit({ id: true, title: true, enabled: true }).extend({
+  ...authoringIdentityShape,
+  title: z7.string().trim().min(1).max(120).optional()
+}).strict().transform((offer) => ({
+  ...offer,
+  title: offer.title ?? offer.reward.reward.title,
+  enabled: true
+}));
+var offerArtifactSchema = z7.union([
+  offerAuthoringSchema,
+  z7.object({ code: z7.string().min(1).max(2e6) }).strict()
+]);
+var offerAvailabilitySchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("available"), remaining: quantity }).strict(),
+  z7.object({ kind: z7.literal("out-of-stock") }).strict(),
+  z7.object({ kind: z7.literal("limit-reached") }).strict(),
+  z7.object({ kind: z7.literal("paused") }).strict()
+]);
+var offerSchema = offerDefinitionSchema.extend({
+  revision: z7.number().int().positive(),
+  available: quantity,
+  redeemed: quantity,
+  availability: offerAvailabilitySchema
+});
+var redeemOfferSchema = z7.object({ actionId: identifier }).strict();
+var redemptionBase = {
+  id: identifier,
+  offer: identifier,
+  member: identifier,
+  reservation: identifier,
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  entitlement: identifier,
+  revision: z7.number().int().positive(),
+  redeemedAt: z7.number().int().safe().nonnegative()
+};
+var redemptionSchema = z7.discriminatedUnion("status", [
+  z7.object({ ...redemptionBase, status: z7.literal("fulfilled") }).strict(),
+  z7.object({
+    ...redemptionBase,
+    status: z7.literal("canceled"),
+    canceledAt: z7.number().int().safe().nonnegative(),
+    reason: z7.string().min(1).max(500)
+  }).strict()
+]);
+var offerControlSchema = z7.object({
+  actionId: identifier,
+  revision: z7.number().int().positive(),
+  enabled: z7.boolean(),
+  reason: z7.string().trim().min(1).max(500)
 }).strict();
-var solanaBalanceSchema = z7.object({
-  address: solanaAddressSchema,
-  network: z7.literal("mainnet-beta"),
-  lamports: z7.string().regex(/^(0|[1-9][0-9]*)$/),
-  slot: z7.number().int().nonnegative().safe(),
-  observedAt: z7.number().int().nonnegative()
+var redemptionCancellationSchema = z7.object({
+  actionId: identifier,
+  revision: z7.number().int().positive(),
+  reason: z7.string().trim().min(1).max(500)
 }).strict();
-var walletChainSchema = z7.enum(["solana", "eip155", "cosmos"]);
+function defineOffer(input) {
+  return resourceHandle("offer", offerAuthoringSchema.parse(input));
+}
+
+// src/wallet.ts
+import { z as z8 } from "zod";
+var solanaAddressSchema = z8.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletChainSchema = z8.enum(["solana", "eip155", "cosmos"]);
 var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
-var cosmosNetworkSchema = z7.custom(
+var cosmosNetworkSchema = z8.custom(
   (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
   "Use a Cosmos network: cosmos:<chain ID>"
 );
+var cosmosDenomSchema = z8.string().regex(
+  /^[a-zA-Z][a-zA-Z0-9/:._-]{2,127}$/,
+  "Use a Cosmos bank denomination such as uatom or uosmo"
+);
 function cosmosChain(chain) {
   if (typeof chain === "string" && !chain.startsWith("cosmos:")) {
     throw new Error('Use a Cosmos network such as "cosmos:cosmoshub-4"');
@@ -784,51 +979,51 @@ function cosmosChain(chain) {
   return { ...value, network };
 }
 var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var evmAddressSchema = z7.string().regex(/^0x[0-9a-fA-F]{40}$/);
-var cosmosAddressSchema = z7.string().min(8).max(90).regex(
+var evmAddressSchema = z8.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z8.string().min(8).max(90).regex(
   /^(?:[a-z][a-z0-9]{0,82}1[02-9ac-hj-np-z]{38,}|[A-Z][A-Z0-9]{0,82}1[02-9AC-HJ-NP-Z]{38,})$/
 );
-var walletAddressInputSchema = z7.discriminatedUnion("chain", [
-  z7.object({ chain: z7.literal("solana"), address: solanaAddressSchema }).strict(),
-  z7.object({
-    chain: z7.literal("eip155"),
+var walletAddressInputSchema = z8.discriminatedUnion("chain", [
+  z8.object({ chain: z8.literal("solana"), address: solanaAddressSchema }).strict(),
+  z8.object({
+    chain: z8.literal("eip155"),
     address: evmAddressSchema,
     /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
-    chainId: z7.number().int().positive().safe().optional()
+    chainId: z8.number().int().positive().safe().optional()
   }).strict(),
-  z7.object({
-    chain: z7.literal("cosmos"),
+  z8.object({
+    chain: z8.literal("cosmos"),
     network: cosmosNetworkSchema,
     address: cosmosAddressSchema
   }).strict()
 ]);
-var walletMessageChallengeSchema = z7.object({
-  id: z7.string().min(1).max(200),
-  purpose: z7.enum(["link", "sign-in"]),
+var walletMessageChallengeSchema = z8.object({
+  id: z8.string().min(1).max(200),
+  purpose: z8.enum(["link", "sign-in"]),
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
   /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
-  address: z7.string(),
-  message: z7.string().max(4096),
-  expiresAt: z7.number().int()
+  address: z8.string(),
+  message: z8.string().max(4096),
+  expiresAt: z8.number().int()
 });
-var walletSignatureSchema = z7.object({
-  challenge: z7.string().min(1).max(200),
+var walletSignatureSchema = z8.object({
+  challenge: z8.string().min(1).max(200),
   /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
-  signature: z7.string().min(1).max(256),
+  signature: z8.string().min(1).max(256),
   /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
-  publicKey: z7.string().max(128).optional()
+  publicKey: z8.string().max(128).optional()
 }).strict();
-var linkedWalletSchema = z7.object({
+var linkedWalletSchema = z8.object({
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
-  address: z7.string(),
-  verifiedAt: z7.number().int().nonnegative(),
-  revision: z7.number().int().positive(),
+  address: z8.string(),
+  verifiedAt: z8.number().int().nonnegative(),
+  revision: z8.number().int().positive(),
   /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
-  signIn: z7.boolean()
+  signIn: z8.boolean()
 });
-var walletUnlinkInputSchema = z7.object({ chain: walletChainSchema, address: z7.string().min(1).max(100) }).strict();
+var walletUnlinkInputSchema = z8.object({ chain: walletChainSchema, address: z8.string().min(1).max(100) }).strict();
 async function walletAddressInput(signer) {
   const address = await signer.address();
   switch (signer.chain) {
@@ -852,10 +1047,10 @@ async function walletAddressInput(signer) {
 }
 var WALLETS_PER_CHAIN = 5;
 var walletSignInFamilies = ["solana", "eip155", "cosmos"];
-var walletSignInNetworkSchema = z7.union([z7.enum(walletSignInFamilies), z7.string().regex(cosmosNetworkPattern)]).transform(
-  (value) => value.startsWith("cosmos:") ? "cosmos" : value
-);
-var walletSignInNetworksSchema = z7.array(walletSignInNetworkSchema).transform(
+var walletSignInNetworkSchema = z8.enum(walletSignInFamilies);
+var walletSignInNetworksSchema = z8.array(walletSignInNetworkSchema).max(walletSignInFamilies.length).refine((values) => new Set(values).size === values.length, {
+  message: "Duplicate wallet family"
+}).transform(
   (values) => walletSignInFamilies.filter((family) => values.includes(family))
 );
 function walletSignInNetwork(wallet) {
@@ -878,31 +1073,41 @@ function caip10(wallet, network) {
 function isEvmChainId(value) {
   return /^eip155:[1-9][0-9]{0,15}$/.test(value);
 }
-var evmChainIdSchema = z7.custom(
+var evmChainIdSchema = z8.custom(
   (value) => typeof value === "string" && isEvmChainId(value),
   'Use an EVM chain ID such as "eip155:8453"'
 );
-var units = z7.string().regex(/^(0|[1-9][0-9]*)$/);
-var walletBalanceSchema = z7.object({
-  /** Canonical CAIP-2 ID: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` or `eip155:<chain ID>`. */
-  chain: z7.string(),
-  /** The canonical mint (base58) or EIP-55 contract address; null for the native coin. */
-  token: z7.string().nullable(),
-  /** Null only for an ERC-20 contract without `decimals()`. */
-  decimals: z7.number().int().min(0).max(255).nullable(),
+var units = z8.string().regex(/^(0|[1-9][0-9]*)$/);
+var walletBalanceSchema = z8.object({
+  /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
+  chain: z8.string(),
+  /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
+  token: z8.string().nullable(),
+  /** Null when token metadata does not report decimals. */
+  decimals: z8.number().int().min(0).max(255).nullable(),
   /** The sum over `wallets`. */
   total: units,
-  wallets: z7.array(z7.object({ address: z7.string(), amount: units }).strict()),
-  /** Solana: the lowest slot the reads saw. EVM: the latest block when the read started (approximate). */
-  at: z7.object({ kind: z7.enum(["slot", "block"]), number: units }).strict(),
-  observedAt: z7.number().int().nonnegative()
+  wallets: z8.array(z8.object({ address: z8.string(), amount: units }).strict()),
+  /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
+  at: z8.object({ kind: z8.enum(["slot", "block"]), number: units }).strict(),
+  observedAt: z8.number().int().nonnegative()
 }).strict();
 
 export {
-  authoringIdentityShape,
-  validateAuthoringIdentity,
-  normalizeAuthoringIdentity,
-  authoringKey,
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
+  pointLedgerSchema,
+  managedPointLedgerSchema,
+  pointLedgerDeclarationSchema,
+  pointLedgerArtifactSchema,
+  pointLedgerReferenceSchema,
+  pointBalanceSchema,
+  pointBalancesSchema,
+  PointEntryKind,
+  pointEntrySchema,
+  pointHistoryQuerySchema,
+  pointHistoryPageSchema,
+  engagementBudgetSchema,
   engagementDefinitionSchema,
   engagementScoreInputSchema,
   engagementScoreSchema,
@@ -919,11 +1124,10 @@ export {
   engagementBoundaryPageSchema,
   engagementArtifactSchema,
   engagementDeploymentEntrySchema,
-  isRequestError,
-  RequestError,
   RelayErrorCode,
   isRelayError,
   RelayError,
+  asRelayError,
   clientError,
   parseInput,
   profileVisibilitySchema,
@@ -947,6 +1151,9 @@ export {
   AVATAR_UPLOAD_LIMIT,
   avatarUploadTypes,
   leaderboardWindowSchema,
+  leaderboardPrizeRewardSchema,
+  leaderboardPrizeSchema,
+  leaderboardSettlementPolicySchema,
   leaderboardDefinitionSchema,
   leaderboardAuthoringSchema,
   leaderboardArtifactSchema,
@@ -962,6 +1169,11 @@ export {
   pointsAccountSchema,
   leaderboardExclusionSchema,
   leaderboardGroupSchema,
+  leaderboardSettlementStatusSchema,
+  leaderboardSettlementSummarySchema,
+  leaderboardSettlementRowSchema,
+  leaderboardSettlementSchema,
+  leaderboardSettlementApprovalSchema,
   referralDefinitionSchema,
   referralAuthoringSchema,
   referralArtifactSchema,
@@ -973,14 +1185,22 @@ export {
   referralSummarySchema,
   referralHistorySchema,
   referralManagementSchema,
+  offerPriceSchema,
+  offerLimitSchema,
+  offerDefinitionSchema,
+  offerAuthoringSchema,
+  offerArtifactSchema,
+  offerAvailabilitySchema,
+  offerSchema,
+  redeemOfferSchema,
+  redemptionSchema,
+  offerControlSchema,
+  redemptionCancellationSchema,
+  defineOffer,
   solanaAddressSchema,
-  walletConnectionSchema,
-  walletChallengeInputSchema,
-  walletChallengeSchema,
-  walletProofSchema,
-  solanaBalanceSchema,
   walletChainSchema,
   cosmosNetworkSchema,
+  cosmosDenomSchema,
   cosmosChain,
   solanaMainnet,
   evmAddressSchema,