@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/capability-error-oTd3eYFH.d.ts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+
+declare const xIdSchema: z.ZodString;
+declare const xConnectionSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+declare const xProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodString;
+    name: z.ZodString;
+    bio: z.ZodNullable<z.ZodString>;
+    profileImageUrl: z.ZodNullable<z.ZodString>;
+    followersCount: z.ZodNullable<z.ZodNumber>;
+    verified: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const xPostSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    author: z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodString;
+        name: z.ZodString;
+        verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>;
+    likeCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    replyCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    retweetCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    quoteCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    viewCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    bookmarkCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    isReply: z.ZodBoolean;
+    isRetweet: z.ZodBoolean;
+    isQuoteTweet: z.ZodBoolean;
+    quotedTweetId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    inReplyToUserId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    inReplyToStatusId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    retweetedTweetId: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    media: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
+        type: string;
+        url: string;
+    }[], unknown>>;
+}, z.core.$loose>;
+declare const xRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"connection">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"profile">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"post">;
+    postId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"follows">;
+    userId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"reposted">;
+    postId: z.ZodString;
+}, z.core.$strict>], "operation">;
+type XConnection = z.infer<typeof xConnectionSchema>;
+type XProfile = z.infer<typeof xProfileSchema>;
+type XPost = z.infer<typeof xPostSchema>;
+/**
+ * Reads the member's linked X account and public X data. The account is pinned at the attempt's
+ * first X read: later links and unlinks do not change the attempt. `connection()`, `profile()`,
+ * `follows()` and `reposted()` resolve to `null` when the member has no linked X account;
+ * `post()` reads any public post and resolves to `null` when it does not exist. Provider failures
+ * throw `CapabilityError` with code `"provider-unavailable"`.
+ */
+interface XReader {
+    connection(): Promise<XConnection | null>;
+    profile(): Promise<XProfile | null>;
+    post(input: {
+        postId: string;
+    }): Promise<XPost | null>;
+    follows(input: {
+        userId: string;
+    }): Promise<boolean | null>;
+    reposted(input: {
+        postId: string;
+    }): Promise<boolean | null>;
+}
+
+/**
+ * Why an evaluator capability could not answer:
+ *
+ * - `not-linked`: the call needs a member account that is not linked, and its result cannot be
+ *   null, such as an image check of the member's X profile picture. Readers of the member's own
+ *   accounts return `null` instead.
+ * - `provider-unavailable`: the provider (X, Discord, a chain RPC, AI review) did not answer, or
+ *   the project's integration cannot reach it.
+ * - `author-error`: the call cannot be answered as written: invalid input, an undeclared
+ *   integration, an unknown tracker, a chain Relay does not read, a wallet the member never
+ *   linked, or an image that does not exist.
+ *
+ * Later versions can add codes. Treat an unknown code as a failure its `message` explains.
+ */
+declare const capabilityErrorCodes: readonly ["not-linked", "provider-unavailable", "author-error"];
+/** @compat open */
+type KnownCapabilityErrorCode = (typeof capabilityErrorCodes)[number];
+/** A known code, or one a newer Relay added. */
+type CapabilityErrorCode = KnownCapabilityErrorCode | (string & {});
+/**
+ * A capability failure as it crosses the sandbox boundary and as Relay captures it. Open, so a
+ * newer Relay can add codes and fields without breaking an older evaluator or Worker.
+ */
+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>;
+/**
+ * Thrown by an evaluator capability (`ctx.x`, `ctx.discord`, `ctx.wallet`, `ctx.trackers`,
+ * `ctx.images`, `ctx.review`) that could not answer. A capability whose subject is missing (an
+ * account the member has not linked, a deleted post or message) returns `null` instead of
+ * throwing.
+ *
+ * Catch it to decide yourself; rethrow anything else. An uncaught retryable error makes Relay
+ * retry the attempt later; an uncaught one that is not retryable fails it.
+ *
+ * ```ts
+ * try {
+ *   return (await ctx.x.follows({ userId })) ? decision.accept() : decision.reject({ reason })
+ * } catch (error) {
+ *   if (error instanceof CapabilityError && error.code === "provider-unavailable")
+ *     return decision.review({ reason: "X is unavailable" })
+ *   throw error
+ * }
+ * ```
+ */
+declare class CapabilityError extends Error {
+    readonly code: CapabilityErrorCode;
+    readonly retryable: boolean;
+    constructor(code: CapabilityErrorCode, message: string, options?: {
+        retryable?: boolean;
+    });
+    static [Symbol.hasInstance](value: unknown): boolean;
+    /**
+     * The error for a captured or transported failure. A code this SDK does not know is never
+     * retryable: nothing tells it a retry would help.
+     */
+    static from(failure: CapabilityFailure): CapabilityError;
+}
+
+export { CapabilityError as C, type KnownCapabilityErrorCode as K, type XReader as X, type CapabilityErrorCode as a, type CapabilityFailure as b, capabilityErrorCodes as c, type XConnection as d, type XPost as e, type XProfile as f, capabilityFailureSchema as g, xIdSchema as h, xPostSchema as i, xProfileSchema as j, xRequestSchema as k, xConnectionSchema as x };

package/dist/chunk-2UAVZCMH.js

@@ -0,0 +1,314 @@
+import {
+  RequestError,
+  isRequestError
+} from "./chunk-NPGENI7K.js";
+import {
+  responseShape
+} from "./chunk-46C33ASD.js";
+
+// src/errors.ts
+import { z } from "zod";
+var RelayErrorCode = {
+  /** The call needs a signed-in member. */
+  NotSignedIn: "not-signed-in",
+  /** The session changed since the app read it (the `session` option). Reload before retrying. */
+  StaleSession: "stale-session",
+  /** The input failed validation before it was sent. */
+  InvalidInput: "invalid-input",
+  /** Relay's answer was not JSON or not the expected shape (kind `invalid-response`). */
+  InvalidResponse: "invalid-response",
+  /** The transport failed, before a response or while reading its body (kind `network`). */
+  Network: "network",
+  /** The client's deadline elapsed (kind `timeout`). */
+  Timeout: "timeout",
+  /** The caller cancelled the request (kind `aborted`). */
+  Aborted: "aborted",
+  /** A quest or collection the call named is not in the member's experience. */
+  NotFound: "not-found",
+  /** The quest has no failed attempt the member can retry. */
+  RetryUnavailable: "retry-unavailable",
+  /**
+   * 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",
+  /** The member has not met the quest's prerequisites; `missing` lists them. */
+  PrerequisitesIncomplete: "prerequisites-incomplete",
+  /** The quest is archived or retired: it takes no new participation. */
+  QuestClosed: "quest-closed",
+  /** An operator paused the quest. */
+  QuestPaused: "quest-paused",
+  /** An operator locked the member's profile; hiding it is still allowed. */
+  ProfileLocked: "profile-locked",
+  /** No member in the project has the invitation code the member accepted. */
+  InvitationNotFound: "invitation-not-found",
+  /** The email sign-in code is wrong; the member can type it again. */
+  InvalidCode: "invalid-code",
+  /** The email sign-in code expired, was used or had too many attempts; request another. */
+  CodeExpired: "code-expired",
+  /** The wallet sign-in challenge expired, was used or changed; start sign-in again. */
+  ChallengeExpired: "challenge-expired",
+  /** Too many requests; `retryAfter` says how long to wait when Relay knows. */
+  RateLimited: "rate-limited"
+};
+var relayErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RelayError");
+function isRelayError(value) {
+  return isRequestError(value) && value[relayErrorBrand] === true;
+}
+var RelayError = class extends RequestError {
+  name = "RelayError";
+  [relayErrorBrand] = true;
+  /** Which window refused admission when `code` is `outside-window`. */
+  window;
+  /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
+  missing;
+  constructor(message, details) {
+    super(message, details);
+    this.window = details.window;
+    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 });
+}
+function parseInput(schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw clientError(
+      z.prettifyError(parsed.error),
+      RelayErrorCode.InvalidInput,
+      { cause: parsed.error }
+    );
+  }
+  return parsed.data;
+}
+
+// src/wallet.ts
+import { z as z2 } from "zod";
+var solanaAddressSchema = z2.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletChainSchema = z2.enum(["solana", "eip155", "cosmos"]);
+var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
+var cosmosNetworkSchema = z2.custom(
+  (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
+  "Use a Cosmos network: cosmos:<chain ID>"
+);
+var cosmosDenomSchema = z2.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"');
+  }
+  const value = typeof chain === "string" ? { chainId: chain.slice("cosmos:".length) } : chain;
+  if (typeof value?.chainId !== "string") {
+    throw new Error(
+      'Pass a Cosmos chain as { chainId } or a network such as "cosmos:cosmoshub-4"'
+    );
+  }
+  const network = `cosmos:${value.chainId}`;
+  if (!cosmosNetworkPattern.test(network)) {
+    throw new Error(
+      "A Cosmos chain ID has 1 to 32 letters, digits, hyphens or underscores"
+    );
+  }
+  if (value.chainInfo && value.chainInfo.chainId !== value.chainId) {
+    throw new Error("The chain info describes another chain ID");
+  }
+  return { ...value, network };
+}
+var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var evmAddressSchema = z2.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z2.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 = z2.discriminatedUnion("chain", [
+  z2.object({ chain: z2.literal("solana"), address: solanaAddressSchema }).strict(),
+  z2.object({
+    chain: z2.literal("eip155"),
+    address: evmAddressSchema,
+    /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
+    chainId: z2.number().int().positive().safe().optional()
+  }).strict(),
+  z2.object({
+    chain: z2.literal("cosmos"),
+    network: cosmosNetworkSchema,
+    address: cosmosAddressSchema
+  }).strict()
+]);
+var walletMessageChallengeSchema = z2.object({
+  id: z2.string().min(1).max(200),
+  purpose: z2.enum(["link", "sign-in"]),
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
+  address: z2.string(),
+  message: z2.string().max(4096),
+  expiresAt: z2.number().int()
+});
+var walletSignatureSchema = z2.object({
+  challenge: z2.string().min(1).max(200),
+  /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
+  signature: z2.string().min(1).max(256),
+  /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
+  publicKey: z2.string().max(128).optional()
+}).strict();
+var linkedWalletSchema = z2.object({
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  address: z2.string(),
+  verifiedAt: z2.number().int().nonnegative(),
+  revision: z2.number().int().positive(),
+  /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
+  signIn: z2.boolean()
+});
+var walletUnlinkInputSchema = z2.object({ chain: walletChainSchema, address: z2.string().min(1).max(100) }).strict();
+async function walletAddressInput(signer) {
+  const address = await signer.address();
+  switch (signer.chain) {
+    case "solana":
+      return { chain: "solana", address };
+    case "eip155":
+      return {
+        chain: "eip155",
+        address,
+        ...signer.chainId ? { chainId: await signer.chainId() } : {}
+      };
+    case "cosmos":
+      if (!signer.network) {
+        throw clientError(
+          "Choose the Cosmos chain for this wallet",
+          RelayErrorCode.InvalidInput
+        );
+      }
+      return { chain: "cosmos", network: signer.network, address };
+  }
+}
+var WALLETS_PER_CHAIN = 5;
+var walletSignInFamilies = ["solana", "eip155", "cosmos"];
+var walletSignInNetworkSchema = z2.enum(walletSignInFamilies);
+var walletSignInNetworksSchema = z2.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) {
+  return wallet.chain;
+}
+function caip10(wallet, network) {
+  if (wallet.chain === "cosmos") {
+    if (!wallet.network || network && network !== wallet.network) {
+      throw new Error("A Cosmos wallet belongs to its own network");
+    }
+    return `${wallet.network}:${wallet.address}`;
+  }
+  const selected = network ?? (wallet.chain === "solana" ? solanaMainnet : "eip155:1");
+  const valid = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(selected) : isEvmChainId(selected);
+  if (!valid) {
+    throw new Error(`Use a ${wallet.chain} network for this wallet`);
+  }
+  return `${selected}:${wallet.address}`;
+}
+function isEvmChainId(value) {
+  return /^eip155:[1-9][0-9]{0,15}$/.test(value);
+}
+var evmChainIdSchema = z2.custom(
+  (value) => typeof value === "string" && isEvmChainId(value),
+  'Use an EVM chain ID such as "eip155:8453"'
+);
+var units = z2.string().regex(/^(0|[1-9][0-9]*)$/);
+var walletBalanceSchema = responseShape(
+  z2.object({
+    /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
+    chain: z2.string(),
+    /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
+    token: z2.string().nullable(),
+    /** Null when token metadata does not report decimals. */
+    decimals: z2.number().int().min(0).max(255).nullable(),
+    /** The sum over `wallets`. */
+    total: units,
+    wallets: z2.array(
+      z2.object({ address: z2.string(), amount: units }).strict()
+    ),
+    /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
+    at: z2.object({ kind: z2.enum(["slot", "block"]), number: units }).strict(),
+    observedAt: z2.number().int().nonnegative()
+  }).strict()
+);
+
+export {
+  RelayErrorCode,
+  isRelayError,
+  RelayError,
+  asRelayError,
+  clientError,
+  parseInput,
+  solanaAddressSchema,
+  walletChainSchema,
+  cosmosNetworkSchema,
+  cosmosDenomSchema,
+  cosmosChain,
+  solanaMainnet,
+  evmAddressSchema,
+  cosmosAddressSchema,
+  walletAddressInputSchema,
+  walletMessageChallengeSchema,
+  walletSignatureSchema,
+  linkedWalletSchema,
+  walletUnlinkInputSchema,
+  walletAddressInput,
+  WALLETS_PER_CHAIN,
+  walletSignInFamilies,
+  walletSignInNetworkSchema,
+  walletSignInNetworksSchema,
+  walletSignInNetwork,
+  caip10,
+  isEvmChainId,
+  evmChainIdSchema,
+  walletBalanceSchema
+};