@domino-sdk/relay 1.67.0 → 1.69.0

package/dist/chunk-WNEQEDMU.js

@@ -0,0 +1,427 @@
+import {
+  activityTypeSchema
+} from "./chunk-ODJGTFPY.js";
+import {
+  completionRecordSchema,
+  completionSourceSchema,
+  identifier,
+  isSolanaNetwork,
+  pageCursorSchema,
+  pageLimit,
+  solanaAddressSchema,
+  solanaSignatureSchema
+} from "./chunk-CQVKOD3B.js";
+
+// src/server/webhooks.ts
+import * as z from "zod";
+var PayoutSourceKind = {
+  Quest: "quest",
+  Leaderboard: "leaderboard",
+  Engagement: "engagement",
+  Manual: "manual"
+};
+var webhookEventSchema = /* @__PURE__ */ (() => z.object({
+  id: z.string().uuid(),
+  version: z.literal(1),
+  type: activityTypeSchema,
+  createdAt: z.number().int().nonnegative(),
+  organization: z.string(),
+  project: z.string(),
+  environment: z.enum(["test", "live"]),
+  data: z.record(z.string(), z.json())
+}))();
+var walletLinkedEventDataSchema = /* @__PURE__ */ (() => z.object({
+  member: z.string(),
+  chain: z.string(),
+  network: z.string().nullable(),
+  address: z.string()
+}))();
+var webhookControlInputSchema = /* @__PURE__ */ (() => z.object({ actionId: z.string().uuid().optional() }).strict())();
+var webhookInputSchema = /* @__PURE__ */ (() => z.object({
+  url: z.url().max(2048).refine((value) => {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && !url2.username && !url2.password && !url2.hash;
+  }, "Use an HTTPS URL without credentials or a fragment"),
+  types: z.array(activityTypeSchema).min(1).max(100).refine((v) => new Set(v).size === v.length)
+}).strict())();
+var webhookCreateInputSchema = /* @__PURE__ */ (() => webhookInputSchema.extend({ actionId: z.string().uuid().optional() }).strict())();
+var webhookRotateInputSchema = /* @__PURE__ */ (() => z.object({ actionId: z.string().uuid().optional() }).strict())();
+var webhookUpdateSchema = /* @__PURE__ */ (() => webhookInputSchema.partial().extend({ enabled: z.boolean().optional() }).strict())();
+var webhookEndpointSchema = /* @__PURE__ */ (() => z.object({
+  ...webhookInputSchema.shape,
+  id: z.string().uuid(),
+  enabled: z.boolean(),
+  disabledReason: z.string().nullable(),
+  consecutiveFailures: z.number().int().nonnegative(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+}))();
+var webhookEndpointStateSchema = /* @__PURE__ */ (() => webhookEndpointSchema.extend({
+  revision: z.number().int().nonnegative(),
+  deletedAt: z.number().int().safe().nonnegative().nullable()
+}))();
+var webhookDeleteInputSchema = /* @__PURE__ */ (() => z.strictObject({
+  actionId: z.string().uuid().default(() => crypto.randomUUID()),
+  expectedRevision: z.number().int().nonnegative(),
+  reason: z.string().trim().min(1).max(500)
+}))();
+var webhookStateQuerySchema = /* @__PURE__ */ (() => z.strictObject({
+  cursor: pageCursorSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+}))();
+var webhookStatePageSchema = /* @__PURE__ */ (() => z.object({
+  items: z.array(webhookEndpointStateSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var webhookSecretSchema = /* @__PURE__ */ (() => z.object({
+  endpoint: webhookEndpointSchema,
+  secret: z.string(),
+  previousValidUntil: z.number().nullable()
+}))();
+var webhookDeliverySchema = /* @__PURE__ */ (() => z.object({
+  id: z.string().uuid(),
+  endpoint: z.string().uuid(),
+  event: webhookEventSchema,
+  status: z.enum(["pending", "delivered", "failed", "skipped"]),
+  attempts: z.number().int().nonnegative(),
+  responseStatus: z.number().nullable(),
+  lastError: z.string().nullable(),
+  createdAt: z.number(),
+  deliveredAt: z.number().nullable(),
+  replayOf: z.string().uuid().nullable()
+}))();
+var webhookQuerySchema = /* @__PURE__ */ (() => z.object({
+  /** A page's `nextCursor`: the deliveries after it, newest first. */
+  cursor: pageCursorSchema.optional(),
+  /** @deprecated Use `cursor`. Removed in 2.0.0. */
+  before: z.string().uuid().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+}).strict())();
+var webhookDeliveryPageSchema = /* @__PURE__ */ (() => z.object({
+  items: z.array(webhookDeliverySchema),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: z.string().uuid().nullable()
+}))();
+var WEBHOOK_MAX_BYTES = 64 * 1024;
+async function verifyWebhook(input) {
+  const bytes = new TextEncoder().encode(input.body);
+  const tolerance = input.toleranceSeconds ?? 300;
+  const now = input.now ?? Date.now();
+  if (bytes.length > WEBHOOK_MAX_BYTES || !Number.isFinite(now) || !Number.isFinite(tolerance) || tolerance < 0 || tolerance > 300) {
+    throw new Error("Invalid webhook verification input");
+  }
+  const parts = input.signature.split(",");
+  const timestamps = parts.filter((part) => part.startsWith("t="));
+  const timestamp = timestamps[0]?.slice(2) ?? "";
+  const signatures = parts.filter((part) => /^v1=[a-f0-9]{64}$/.test(part)).map((part) => part.slice(3));
+  if (timestamps.length !== 1 || !/^\d{1,12}$/.test(timestamp) || Math.abs(now / 1e3 - Number(timestamp)) > tolerance || signatures.length < 1 || signatures.length > 2) {
+    throw new Error("Invalid or expired webhook signature");
+  }
+  const secrets = typeof input.secret === "string" ? [input.secret] : input.secret;
+  const message = new TextEncoder().encode(`${timestamp}.${input.body}`);
+  for (const secret of secrets) {
+    if (!secret) {
+      continue;
+    }
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    for (const signature of signatures) {
+      const digest = Uint8Array.from(
+        signature.match(/../g) ?? [],
+        (byte) => Number.parseInt(byte, 16)
+      );
+      if (await crypto.subtle.verify("HMAC", key, digest, message)) {
+        return webhookEventSchema.parse(JSON.parse(input.body));
+      }
+    }
+  }
+  throw new Error("Invalid webhook signature");
+}
+
+// src/server/completions.ts
+import * as z2 from "zod";
+var completionRevokeSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  reason: z2.string().trim().min(1).max(500),
+  freeOccurrence: z2.boolean().default(false)
+}).strict())();
+var RevokedEntitlementOutcome = {
+  /** No other completion grants the reward: it is void, after cancelling a handover in progress. */
+  Voided: "voided",
+  /** Lowered to the best tier another completion grants, after cancelling a handover in progress. */
+  Downgraded: "downgraded",
+  /** Another completion grants the same tier, or it was already void. */
+  Kept: "kept",
+  /** Already collected: its earned tier follows the other completions, and the item stays handed over. */
+  Flagged: "flagged"
+};
+var RevokedDeliveryOutcome = {
+  /** The role was delivered and stays: remove it in Discord if appropriate. */
+  Flagged: "flagged",
+  /** The grant was stopped before any call to Discord. */
+  Cancelled: "cancelled",
+  /** The grant was stopped, but a call to Discord may already have been sent and can still land. */
+  InFlight: "in-flight",
+  /** The grant had failed, so Discord never received the role. */
+  NotDelivered: "not-delivered"
+};
+var RevokedReferralOutcome = {
+  /** The inviter's rewards for this member are reversed. */
+  Unqualified: "unqualified",
+  /** Qualified on another accepted completion of the program's quest instead. */
+  Requalified: "requalified"
+};
+var entitlementOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var deliveryOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var referralOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var completionRevocationSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
+  quest: identifier,
+  member: identifier,
+  /** What paid the revoked completion. `source.id` repeats `quest`. */
+  source: completionSourceSchema.optional(),
+  revokedAt: z2.number(),
+  occurrenceFreed: z2.boolean(),
+  badges: z2.array(z2.object({ badge: identifier, stillAwarded: z2.boolean() })).optional(),
+  groups: z2.array(z2.object({ group: identifier, stillMember: z2.boolean() })).optional(),
+  points: z2.array(
+    z2.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier.nullable(),
+      reversed: z2.number().int(),
+      unreversed: z2.number().int()
+    })
+  ),
+  entitlements: z2.array(
+    z2.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: entitlementOutcomeSchema,
+      status: z2.string()
+    })
+  ),
+  deliveries: z2.array(
+    z2.object({
+      delivery: z2.string(),
+      roleId: z2.string(),
+      outcome: deliveryOutcomeSchema,
+      /**
+       * By Relay's records, another accepted, unrevoked completion of the member also granted this
+       * role to the same Discord account and server. Relay does not read Discord's membership.
+       */
+      stillGranted: z2.boolean()
+    })
+  ),
+  referrals: z2.array(
+    z2.object({
+      program: identifier,
+      outcome: referralOutcomeSchema
+    })
+  ),
+  streakMilestone: z2.boolean(),
+  budgets: z2.array(
+    z2.object({ budget: identifier, released: z2.number().int().nonnegative() })
+  ).optional()
+}))();
+var completionRestoreSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  reason: z2.string().trim().min(1).max(500)
+}).strict())();
+var RestoredEntitlementOutcome = {
+  /** The revocation voided it, and it is available again. */
+  Restored: "restored",
+  /** The revocation lowered or flagged it: its earned tier is the completion's again. */
+  Raised: "raised",
+  /** It changed since the revocation (an operator restored, voided or corrected it), so it stays. */
+  Kept: "kept"
+};
+var RestoredDeliveryOutcome = {
+  /** The grant had not reached Discord, and it is queued again. */
+  Requeued: "requeued",
+  /** The grant counts again for reconciliation, and its delivery status stays. */
+  Kept: "kept"
+};
+var RestoredReferralOutcome = {
+  /** The member qualifies on this completion again. */
+  Qualified: "qualified",
+  /** The program is disabled or gone, or the referral is suspended, so nothing changed. */
+  Kept: "kept"
+};
+var openOutcome = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var completionRestorationSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
+  quest: identifier,
+  member: identifier,
+  source: completionSourceSchema.optional(),
+  restoredAt: z2.number(),
+  points: z2.array(
+    z2.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier,
+      amount: z2.number().int()
+    })
+  ),
+  badges: z2.array(z2.object({ badge: identifier })),
+  groups: z2.array(z2.object({ group: identifier, added: z2.boolean() })),
+  entitlements: z2.array(
+    z2.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: openOutcome,
+      status: z2.string()
+    })
+  ),
+  deliveries: z2.array(
+    z2.object({
+      delivery: z2.string(),
+      roleId: z2.string(),
+      outcome: openOutcome
+    })
+  ),
+  referrals: z2.array(
+    z2.object({
+      program: identifier,
+      outcome: openOutcome
+    })
+  ),
+  streakMilestone: z2.boolean(),
+  budgets: z2.array(
+    z2.object({ budget: identifier, charged: z2.number().int().nonnegative() })
+  ).optional()
+}))();
+var completionRevocationShortfallSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  quest: identifier,
+  revokedAt: z2.number().int().nonnegative().safe(),
+  unreversedPoints: z2.record(identifier, z2.number().int().positive().safe())
+}))();
+var revokedCompletionSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  quest: identifier,
+  /** The completion key: its occurrence, such as `once` or a day. */
+  key: z2.string(),
+  revokedAt: z2.number().int().nonnegative().safe(),
+  /** Why it was revoked, and what the revoke did, which a restore re-applies. */
+  reason: z2.string().optional(),
+  revocation: completionRevocationSchema.optional()
+}))();
+var maxCompletionReceipts = 20;
+var receiptNetworkPattern = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/;
+var receiptValue = /* @__PURE__ */ (() => z2.string().min(1).max(256).regex(/^[\x21-\x7e]+$/, "Use printable characters without spaces"))();
+var completionReceiptInputSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  key: z2.string().regex(
+    /^[a-z0-9][a-z0-9._-]{0,63}$/,
+    "Use 1 to 64 lowercase letters, digits, dots, hyphens or underscores"
+  ),
+  network: z2.string().regex(
+    receiptNetworkPattern,
+    "Use a CAIP-2 chain ID such as solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+  ),
+  signature: receiptValue,
+  asset: receiptValue.optional(),
+  recipient: receiptValue.optional(),
+  label: z2.string().trim().min(1).max(120).optional()
+}).strict().superRefine((receipt, context) => {
+  if (!isSolanaNetwork(receipt.network)) {
+    return;
+  }
+  if (!solanaSignatureSchema.safeParse(receipt.signature).success) {
+    context.addIssue({
+      code: "custom",
+      path: ["signature"],
+      message: "Use a Solana transaction signature: base58, 64 bytes"
+    });
+  }
+  for (const field of ["asset", "recipient"]) {
+    const value = receipt[field];
+    if (value !== void 0 && !solanaAddressSchema.safeParse(value).success) {
+      context.addIssue({
+        code: "custom",
+        path: [field],
+        message: "Use a base58 Solana address"
+      });
+    }
+  }
+}))();
+var completionReceiptSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID for a leaderboard prize's completion. */
+  quest: identifier,
+  member: identifier,
+  key: z2.string(),
+  network: z2.string(),
+  signature: z2.string(),
+  asset: z2.string().nullable(),
+  recipient: z2.string().nullable(),
+  label: z2.string().nullable(),
+  recordedAt: z2.number().int().nonnegative().safe(),
+  /** The operator or key that recorded it. */
+  recordedBy: z2.string().nullable(),
+  completionRevokedAt: z2.number().int().nonnegative().safe().nullable()
+}))();
+var completionReceiptListSchema = /* @__PURE__ */ (() => z2.array(completionReceiptSchema))();
+var memberCompletionQuerySchema = /* @__PURE__ */ (() => z2.strictObject({
+  member: identifier,
+  quest: identifier.optional(),
+  cursor: pageCursorSchema.optional(),
+  limit: pageLimit
+}))();
+var memberCompletionSchema = /* @__PURE__ */ (() => completionRecordSchema.extend({
+  completedAt: z2.number().int().nonnegative().safe().nullable()
+}))();
+var memberCompletionPageSchema = /* @__PURE__ */ (() => z2.object({
+  items: z2.array(memberCompletionSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+
+export {
+  PayoutSourceKind,
+  webhookEventSchema,
+  walletLinkedEventDataSchema,
+  webhookControlInputSchema,
+  webhookInputSchema,
+  webhookCreateInputSchema,
+  webhookRotateInputSchema,
+  webhookUpdateSchema,
+  webhookEndpointSchema,
+  webhookEndpointStateSchema,
+  webhookDeleteInputSchema,
+  webhookStateQuerySchema,
+  webhookStatePageSchema,
+  webhookSecretSchema,
+  webhookDeliverySchema,
+  webhookQuerySchema,
+  webhookDeliveryPageSchema,
+  WEBHOOK_MAX_BYTES,
+  verifyWebhook,
+  completionRevokeSchema,
+  RevokedEntitlementOutcome,
+  RevokedDeliveryOutcome,
+  RevokedReferralOutcome,
+  completionRevocationSchema,
+  completionRestoreSchema,
+  RestoredEntitlementOutcome,
+  RestoredDeliveryOutcome,
+  RestoredReferralOutcome,
+  completionRestorationSchema,
+  completionRevocationShortfallSchema,
+  revokedCompletionSchema,
+  maxCompletionReceipts,
+  completionReceiptInputSchema,
+  completionReceiptSchema,
+  completionReceiptListSchema,
+  memberCompletionQuerySchema,
+  memberCompletionSchema,
+  memberCompletionPageSchema
+};

package/dist/{chunk-Q6KTTVOI.js → chunk-WVK3G2J2.js}

@@ -1,7 +1,7 @@
 import {
   clientIdentity,
   retryAfter
-} from "./chunk-5SBA6X5X.js";
+} from "./chunk-SWLW4VN3.js";
 
 // src/http-exchange.ts
 var uncertainStatuses = /* @__PURE__ */ (() => /* @__PURE__ */ new Set([500, 502, 504]))();