@domino-sdk/relay 0.24.0 → 0.25.1

package/dist/browser.js

@@ -1,12 +1,27 @@
 import {
   browserSubmissionStore,
-  createBrowserRelayClient
-} from "./chunk-ND3CVNIW.js";
-import "./chunk-RTBIXGMH.js";
-import "./chunk-ZOL7RYHW.js";
-import "./chunk-57TGYC5Y.js";
-import "./chunk-UYS522ER.js";
+  cosmosSigner,
+  createBrowserRelayClient,
+  discoverCosmosWallets,
+  discoverEvmWallets,
+  discoverSolanaWallets,
+  evmSigner,
+  solanaSigner,
+  walletStandardSolanaSigner
+} from "./chunk-MZFUQQDP.js";
+import "./chunk-S44XSDW2.js";
+import "./chunk-AKB266O5.js";
+import "./chunk-7QICEKC2.js";
+import "./chunk-D6BX627V.js";
+import "./chunk-IXLY3A7B.js";
 export {
   browserSubmissionStore,
-  createBrowserRelayClient
+  cosmosSigner,
+  createBrowserRelayClient,
+  discoverCosmosWallets,
+  discoverEvmWallets,
+  discoverSolanaWallets,
+  evmSigner,
+  solanaSigner,
+  walletStandardSolanaSigner
 };

package/dist/chunk-7QICEKC2.js

@@ -0,0 +1,229 @@
+import {
+  identifier
+} from "./chunk-IXLY3A7B.js";
+
+// src/auth.ts
+import { z } from "zod";
+var authScopeSchema = z.object({
+  organization: identifier,
+  project: identifier,
+  environment: z.enum(["test", "live"])
+}).strict();
+var principalSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("member"), member: identifier }).strict(),
+  z.object({ kind: z.literal("staff"), subject: identifier }).strict(),
+  z.object({ kind: z.literal("operator"), subject: identifier }).strict()
+]);
+var sessionSchema = authScopeSchema.extend({
+  id: identifier,
+  principal: principalSchema,
+  expiresAt: z.number()
+});
+var memberSummarySchema = z.object({
+  member: identifier,
+  avatarSeed: z.string().min(1).max(100)
+});
+var exchangeSchema = authScopeSchema.extend({
+  identity: z.object({ issuer: identifier, subject: z.string().min(1).max(200) }).strict(),
+  role: z.enum(["member", "staff", "operator"])
+}).strict();
+var exchangeResultSchema = z.object({
+  token: z.string(),
+  session: sessionSchema
+});
+
+// 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 walletConnectionSchema = z2.object({
+  chain: z2.literal("solana"),
+  address: solanaAddressSchema,
+  verifiedAt: z2.number().int().nonnegative(),
+  revision: z2.number().int().positive()
+}).strict();
+var walletChallengeInputSchema = z2.object({
+  chain: z2.literal("solana"),
+  address: solanaAddressSchema
+}).strict();
+var walletChallengeSchema = walletChallengeInputSchema.extend({
+  id: z2.string().uuid(),
+  message: z2.string(),
+  expiresAt: z2.number()
+});
+var walletProofSchema = z2.object({
+  challenge: z2.string().uuid(),
+  signature: z2.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
+}).strict();
+var solanaBalanceSchema = z2.object({
+  address: solanaAddressSchema,
+  network: z2.literal("mainnet-beta"),
+  lamports: z2.string().regex(/^(0|[1-9][0-9]*)$/),
+  slot: z2.number().int().nonnegative().safe(),
+  observedAt: z2.number().int().nonnegative()
+}).strict();
+var walletChainSchema = z2.enum(["solana", "eip155", "cosmos"]);
+var cosmosNetworks = {
+  "cosmos:pio-mainnet-1": {
+    chainId: "pio-mainnet-1",
+    prefix: "pb",
+    name: "Provenance"
+  },
+  "cosmos:pio-testnet-1": {
+    chainId: "pio-testnet-1",
+    prefix: "tp",
+    name: "Provenance testnet"
+  }
+};
+var cosmosNetworkSchema = z2.enum([
+  "cosmos:pio-mainnet-1",
+  "cosmos:pio-testnet-1"
+]);
+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]{1,20}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 new Error("Choose a Cosmos network for this wallet");
+      }
+      return { chain: "cosmos", network: signer.network, address };
+  }
+}
+var WALLETS_PER_CHAIN = 5;
+var walletSignInNetworkSchema = z2.enum([
+  "solana",
+  "eip155",
+  "cosmos:pio-mainnet-1",
+  "cosmos:pio-testnet-1"
+]);
+function walletSignInNetwork(wallet) {
+  if (wallet.chain === "cosmos") {
+    if (!wallet.network) {
+      throw new Error("A Cosmos wallet belongs to its own network");
+    }
+    return wallet.network;
+  }
+  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 syntax = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/ : /^eip155:[1-9][0-9]{0,15}$/;
+  if (!syntax.test(selected)) {
+    throw new Error(`Use a ${wallet.chain} network for this wallet`);
+  }
+  return `${selected}:${wallet.address}`;
+}
+function isWalletParticipantRoute(path) {
+  return /^\/v1\/me\/(?:wallet(?:\/challenge|\/verify)?|wallets(?:\/challenge|\/verify|\/unlink)?)$/.test(
+    path
+  );
+}
+var units = z2.string().regex(/^(0|[1-9][0-9]*)$/);
+var walletBalanceSchema = z2.object({
+  /** Canonical CAIP-2 ID: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` or `eip155:<chain ID>`. */
+  chain: z2.string(),
+  /** The canonical mint (base58) or EIP-55 contract address; null for the native coin. */
+  token: z2.string().nullable(),
+  /** Null only for an ERC-20 contract without `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: the lowest slot the reads saw. EVM: the latest block when the read started (approximate). */
+  at: z2.object({ kind: z2.enum(["slot", "block"]), number: units }).strict(),
+  observedAt: z2.number().int().nonnegative()
+}).strict();
+function isWalletSignInRoute(path) {
+  return /^\/v1\/auth\/wallet\/(?:start|verify)$/.test(path);
+}
+
+export {
+  authScopeSchema,
+  principalSchema,
+  sessionSchema,
+  memberSummarySchema,
+  exchangeSchema,
+  exchangeResultSchema,
+  solanaAddressSchema,
+  walletConnectionSchema,
+  walletChallengeInputSchema,
+  walletChallengeSchema,
+  walletProofSchema,
+  solanaBalanceSchema,
+  walletChainSchema,
+  cosmosNetworks,
+  cosmosNetworkSchema,
+  solanaMainnet,
+  evmAddressSchema,
+  cosmosAddressSchema,
+  walletAddressInputSchema,
+  walletMessageChallengeSchema,
+  walletSignatureSchema,
+  linkedWalletSchema,
+  walletUnlinkInputSchema,
+  walletAddressInput,
+  WALLETS_PER_CHAIN,
+  walletSignInNetworkSchema,
+  walletSignInNetwork,
+  caip10,
+  isWalletParticipantRoute,
+  walletBalanceSchema,
+  isWalletSignInRoute
+};

package/dist/{chunk-ZOL7RYHW.js → chunk-AKB266O5.js}

@@ -1,10 +1,13 @@
+import {
+  profileSummarySchema
+} from "./chunk-D6BX627V.js";
 import {
   contentMetricSchema,
   contentMetricsSchema,
   identifier,
   pointsRewardSchema,
   tierRewardSchema
-} from "./chunk-UYS522ER.js";
+} from "./chunk-IXLY3A7B.js";
 
 // src/engagement.ts
 import { z } from "zod";
@@ -417,11 +420,18 @@ var leaderboardQuerySchema = z4.object({
   cursor: z4.string().max(4096).optional()
 }).strict();
 var leaderboardRowSchema = z4.object({
+  /** The row's stable key: a pseudonym per board and member. */
   participant: identifier,
   member: identifier.optional(),
+  /** The profile's name where the viewer can see it, otherwise the pseudonym's. */
   name: z4.string(),
   score: integer,
-  rank: integer.positive()
+  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)
 });
 var leaderboardPageSchema = z4.object({
   leaderboard: identifier,
@@ -517,6 +527,37 @@ var leaderboardGroupSchema = z4.object({
   reason: z4.string().trim().min(1).max(1e3)
 }).strict();
 
+// src/units.ts
+function checkDecimals(decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255) {
+    throw new Error("Token decimals must be an integer from 0 to 255");
+  }
+}
+function parseUnits(value, decimals) {
+  checkDecimals(decimals);
+  const match = /^(\d+)(?:\.(\d+))?$/.exec(value.trim());
+  if (!match) {
+    throw new Error(`Use a decimal amount such as "1.5", not "${value}"`);
+  }
+  const [, whole, fraction = ""] = match;
+  const significant = fraction.replace(/0+$/, "");
+  if (significant.length > decimals) {
+    throw new Error(
+      `"${value}" has more than ${decimals} decimal places, which this token cannot hold`
+    );
+  }
+  return BigInt(whole + significant.padEnd(decimals, "0"));
+}
+function formatUnits(amount3, decimals) {
+  checkDecimals(decimals);
+  const value = typeof amount3 === "bigint" ? amount3 : BigInt(amount3);
+  const sign = value < 0n ? "-" : "";
+  const digits = (value < 0n ? -value : value).toString().padStart(decimals + 1, "0");
+  const whole = digits.slice(0, digits.length - decimals);
+  const fraction = digits.slice(digits.length - decimals).replace(/0+$/, "");
+  return sign + whole + (fraction ? "." + fraction : "");
+}
+
 export {
   engagementDefinitionSchema,
   engagementScoreInputSchema,
@@ -566,5 +607,7 @@ export {
   pointsResultSchema,
   pointsAccountSchema,
   leaderboardExclusionSchema,
-  leaderboardGroupSchema
+  leaderboardGroupSchema,
+  parseUnits,
+  formatUnits
 };

package/dist/chunk-D6BX627V.js

@@ -0,0 +1,175 @@
+import {
+  identifier
+} from "./chunk-IXLY3A7B.js";
+
+// src/profiles.ts
+import { z } from "zod";
+var count = z.number().int().nonnegative().safe();
+var profileVisibilitySchema = z.enum([
+  "private",
+  "participants",
+  "public"
+]);
+var profileDefaultsSchema = z.enum(["generated", "accounts"]);
+var avatarProviderSchema = z.enum(["x", "discord", "google"]);
+var avatarSeedSchema = z.string().min(1).max(100);
+var profileAvatarSchema = z.discriminatedUnion("source", [
+  z.object({
+    source: z.literal("upload"),
+    url: z.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z.object({
+    source: z.literal("account"),
+    provider: avatarProviderSchema,
+    url: z.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z.object({ source: z.literal("generated"), seed: avatarSeedSchema })
+]);
+var profileSummarySchema = z.object({
+  id: identifier,
+  name: z.string(),
+  avatar: profileAvatarSchema
+});
+var invisible = /[\p{Cc}؜᠎​-‏‪-‮⁠-⁤⁦-⁩]/u;
+var displayNameSchema = z.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
+  z.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
+);
+var profileUpdateSchema = z.object({
+  displayName: displayNameSchema.nullable().optional(),
+  avatar: z.discriminatedUnion("source", [
+    z.object({
+      source: z.literal("account"),
+      provider: avatarProviderSchema
+    }).strict(),
+    z.object({ source: z.literal("generated") }).strict()
+  ]).nullable().optional(),
+  hidden: z.boolean().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((field) => field !== void 0),
+  "Change at least one field"
+);
+var ownProfileSchema = profileSummarySchema.extend({
+  /** The name the member chose, or null for the default. */
+  displayName: z.string().nullable(),
+  /** The avatar the member chose: `default` follows the project's defaults. */
+  avatarChoice: z.enum(["default", "upload", "account", "generated"]),
+  /** The account of an `account` choice. */
+  avatarProvider: avatarProviderSchema.nullable(),
+  hidden: z.boolean(),
+  /** An operator locked the name and avatar; the member can still hide the profile. */
+  locked: z.boolean(),
+  /** Who can see profiles in this project, so the app can explain it. */
+  visibility: profileVisibilitySchema,
+  /** The member's connected accounts a picture or name can come from. */
+  options: z.array(
+    z.object({
+      provider: avatarProviderSchema,
+      name: z.string().nullable(),
+      imageUrl: z.string().url().nullable()
+    })
+  )
+});
+var publicProfileSchema = profileSummarySchema.extend({
+  /** The profile is the viewer's own. */
+  self: z.boolean(),
+  leaderboards: z.array(
+    z.object({
+      leaderboard: identifier,
+      key: identifier.optional(),
+      title: z.string(),
+      rank: count.positive(),
+      score: z.number().int().safe(),
+      /** Ranked participants on the board. */
+      total: count
+    })
+  ).nullable(),
+  quests: z.array(
+    z.object({
+      quest: identifier,
+      key: identifier.optional(),
+      title: z.string(),
+      completions: count.positive(),
+      /** Null for completions recorded before completion times were. */
+      lastCompletedAt: count.nullable()
+    })
+  ).max(200).nullable(),
+  referrals: z.object({
+    /** Members this member invited. */
+    attributed: count,
+    programs: z.array(
+      z.object({
+        program: identifier,
+        key: identifier.optional(),
+        title: z.string(),
+        qualified: count,
+        milestones: z.array(
+          z.object({ id: identifier, count, reached: z.boolean() })
+        )
+      })
+    )
+  }).nullable()
+});
+var profileSettingsSchema = z.object({
+  visibility: profileVisibilitySchema,
+  defaults: profileDefaultsSchema,
+  /** The sections a profile page shows. */
+  sections: z.object({
+    leaderboards: z.boolean(),
+    quests: z.boolean(),
+    referrals: z.boolean()
+  }),
+  revision: count,
+  actor: z.string().nullable(),
+  updatedAt: count.nullable()
+});
+var profileSettingsInputSchema = profileSettingsSchema.omit({ revision: true, actor: true, updatedAt: true }).extend({
+  actionId: identifier,
+  /** The revision the change was made against; a newer one is a 409. */
+  expectedRevision: count,
+  reason: z.string().trim().min(1).max(500)
+}).strict();
+var profileModerationSchema = z.object({
+  actionId: identifier,
+  resetName: z.boolean().default(false),
+  removeAvatar: z.boolean().default(false),
+  /** True locks the name and avatar, false unlocks them. */
+  lock: z.boolean().optional(),
+  reason: z.string().trim().min(1).max(1e3)
+}).strict().refine(
+  (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
+  "Choose an action"
+);
+var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
+  member: identifier,
+  lockedAt: count.nullable(),
+  lockedBy: z.string().nullable(),
+  lockedReason: z.string().nullable(),
+  updatedAt: count
+});
+var AVATAR_UPLOAD_LIMIT = 5 * 1024 * 1024;
+var avatarUploadTypes = ["image/jpeg", "image/png", "image/webp"];
+function isProfileParticipantRoute(path, method) {
+  return method === "GET" && (path === "/v1/me/profile" || /^\/v1\/profiles\/[\w-]+$/.test(path)) || method === "POST" && (path === "/v1/me/profile" || path === "/v1/me/profile/avatar");
+}
+
+export {
+  profileVisibilitySchema,
+  profileDefaultsSchema,
+  avatarProviderSchema,
+  avatarSeedSchema,
+  profileAvatarSchema,
+  profileSummarySchema,
+  displayNameSchema,
+  profileUpdateSchema,
+  ownProfileSchema,
+  publicProfileSchema,
+  profileSettingsSchema,
+  profileSettingsInputSchema,
+  profileModerationSchema,
+  managedProfileSchema,
+  AVATAR_UPLOAD_LIMIT,
+  avatarUploadTypes,
+  isProfileParticipantRoute
+};