@domino-sdk/relay 1.66.1 → 1.68.0

package/dist/{sign-in-providers-BAkGjSXo.d.ts → sign-in-providers-C5_753DZ.d.ts}

@@ -1,6 +1,6 @@
-import { J as SignInProvider } from './accounts-_lNsiR2k.js';
+import { J as SignInProvider } from './accounts-DnpKoJCo.js';
 import * as z from 'zod';
-import { a as TelegramSignInMethods } from './submission-input-ChL1aYNH.js';
+import { a as TelegramSignInMethods } from './submission-input-CaL8drIh.js';
 
 /**
  * `GET /v1/auth/providers`, as `relay.auth.providers()` reads it. Exported as a schema only, for the

package/dist/solana.d.ts

@@ -0,0 +1,171 @@
+import { TransactionSigner, Rpc, GetAccountInfoApi, GetBlockHeightApi, GetLatestBlockhashApi, GetMinimumBalanceForRentExemptionApi, GetSignatureStatusesApi, SendTransactionApi, KeyPairSigner, Address, Signature } from '@solana/kit';
+import { S as SolanaNetwork } from './wallet-DQtJelQQ.js';
+export { s as solanaDevnet, t as solanaMainnet } from './wallet-DQtJelQQ.js';
+import { M as ManagementClient, W as WebhookEvent, C as CompletionReceipt } from './transport-CkidqTOk.js';
+import 'zod';
+import './accounts-DnpKoJCo.js';
+import './tracker-data-CAK942sx.js';
+import './identity-integration-r76xaAax.js';
+import './reward-deliveries-0VvT6LMj.js';
+import './request-error-D_dUPLwo.js';
+import './action-9Xl0StBg.js';
+import './limits-ByVRQePO.js';
+import './automatic-outcomes-CQ3vpiQl.js';
+import './deployments-BCr418BX.js';
+import './offers-xcPbYaEv.js';
+import './catalog-BLGie8Lh.js';
+import './attempt-captures-DMNFMYFb.js';
+
+/**
+ * The RPC methods the badge helpers call. `createSolanaRpc(url)` from `@solana/kit` answers all of
+ * them.
+ */
+type SolanaBadgeRpc = Rpc<GetAccountInfoApi & GetBlockHeightApi & GetLatestBlockhashApi & GetMinimumBalanceForRentExemptionApi & GetSignatureStatusesApi & SendTransactionApi>;
+/** The receipt key `awardSolanaBadge` records a badge under. */
+declare const solanaBadgeReceiptKey = "badge";
+/**
+ * What `awardSolanaBadge` did. `minted` and `already-minted` carry the completion's badge
+ * receipt; `no-wallet` means the member has no proven Solana wallet, and nothing was sent;
+ * `deferred` is `no-wallet` under `whenNoWallet: "defer"`, so `awardOwedSolanaBadges` mints the
+ * badge once the member links one; `ignored` means the event is not a quest completion, or its
+ * quest is outside `quests`.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+type SolanaBadgeAward = {
+    status: "minted";
+    receipt: CompletionReceipt;
+} | {
+    status: "already-minted";
+    receipt: CompletionReceipt;
+} | {
+    status: "no-wallet";
+} | {
+    status: "deferred";
+} | {
+    status: "ignored";
+};
+/** @experimental A minor release can change the Solana badge helpers. */
+type AwardSolanaBadgeInput = {
+    /**
+     * A management client with `points` and `read` permission: it reads the member's wallets and
+     * completions and records the receipt.
+     */
+    management: Pick<ManagementClient, "completions" | "members">;
+    /** A delivery `verifyWebhook` verified. Events other than a quest's `completion.created` are ignored. */
+    event: WebhookEvent;
+    /** The badge's Token-2022 mint, as `createSolanaBadgeMint` created it. */
+    mint: string;
+    /** The mint authority. It signs the mint and pays the fee and the member's token account rent. */
+    authority: TransactionSigner;
+    rpc: SolanaBadgeRpc;
+    /** The cluster `rpc` serves, recorded on the receipt: `solanaMainnet` or `solanaDevnet`. */
+    network: SolanaNetwork;
+    /** Award only completions of these quest IDs. Omit to award every quest's completions. */
+    quests?: readonly string[];
+    /**
+     * What happens when the member has no proven Solana wallet. Both send nothing: `skip` (the
+     * default) answers `no-wallet`, and `defer` answers `deferred`, for a server that also calls
+     * `awardOwedSolanaBadges` on `wallet.linked` to mint the badge once the member links a wallet.
+     */
+    whenNoWallet?: "skip" | "defer";
+    /** Receipt `label` Console shows beside it. */
+    label?: string;
+};
+/**
+ * Mints one unit of a non-transferable Token-2022 badge to the member's most recently linked
+ * proven Solana wallet for a quest's `completion.created` event, and records the transaction as
+ * the completion's `badge` receipt. Call it from your webhook handler; your server holds the mint
+ * authority and pays the fees.
+ *
+ * Exactly once per completion, whatever the deliveries and retries. Before sending, it records the
+ * signed transaction as a `badge-attempt-<n>` receipt, which only one call can record, and only
+ * then sends it. A call that finds an earlier attempt records it as the badge once it landed,
+ * sends a new attempt once it failed or its blockhash expired, and otherwise throws
+ * `SolanaBadgePendingError` without sending, so the delivery is retried later. It waits for the
+ * `confirmed` commitment.
+ *
+ * Requires the optional peer dependencies `@solana/kit` and `@solana-program/token-2022`.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+declare function awardSolanaBadge(input: AwardSolanaBadgeInput): Promise<SolanaBadgeAward>;
+/**
+ * What `awardOwedSolanaBadges` did: `awarded` with each owed completion and what
+ * `awardSolanaBadge` did for it (`minted`, `already-minted`, or `no-wallet` when the member has
+ * unlinked the wallet since), or `ignored` when the event is not a Solana `wallet.linked`.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+type OwedSolanaBadges = {
+    status: "awarded";
+    awards: {
+        completion: string;
+        quest: string;
+        award: SolanaBadgeAward;
+    }[];
+} | {
+    status: "ignored";
+};
+/**
+ * `awardSolanaBadge`'s input for a `wallet.linked` event: the same badge, mint authority and
+ * `quests`.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+type AwardOwedSolanaBadgesInput = Omit<AwardSolanaBadgeInput, "whenNoWallet">;
+/**
+ * Mints the badges a member is owed once they link a Solana wallet: call it from your webhook
+ * handler for `wallet.linked`, next to `awardSolanaBadge` with `whenNoWallet: "defer"` for
+ * `completion.created`. For a Solana wallet, it lists the member's completions that count (not
+ * revoked) of each quest in `quests` (every quest when omitted) and awards each one exactly as
+ * `awardSolanaBadge` does, so a completion that has its `badge` receipt mints nothing and a
+ * redelivered event mints nothing new. Other events and chains are `ignored`.
+ *
+ * It mints one completion at a time and throws on the first failure, such as
+ * `SolanaBadgePendingError`: fail the delivery so Domino retries it, and the retry skips the badges
+ * already minted.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+declare function awardOwedSolanaBadges(input: AwardOwedSolanaBadgesInput): Promise<OwedSolanaBadges>;
+/**
+ * An earlier call's badge transaction for this completion has not landed yet, and its blockhash
+ * is still valid. Nothing was sent; call again later, for example by failing the webhook delivery
+ * so Domino retries it.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+declare class SolanaBadgePendingError extends Error {
+    readonly signature: string;
+    readonly code = "badge-pending";
+    constructor(signature: string);
+}
+/** @experimental A minor release can change the Solana badge helpers. */
+type CreateSolanaBadgeMintInput = {
+    /** Becomes the mint and metadata authority, and pays for the mint account. */
+    authority: TransactionSigner;
+    rpc: SolanaBadgeRpc;
+    /** The badge's on-chain name, symbol and metadata JSON URI, which wallets and explorers show. */
+    name: string;
+    symbol: string;
+    uri: string;
+    /** The new mint's key pair. Omit to generate one. */
+    mint?: KeyPairSigner;
+};
+/**
+ * Creates a badge mint for `awardSolanaBadge`: a Token-2022 mint with 0 decimals, the
+ * NonTransferable extension, so its tokens can't move from the wallet they were minted to, and
+ * on-mint metadata (the metadata pointer and token metadata extensions). Run it once per badge,
+ * for example from a setup script, and keep the mint address.
+ *
+ * @experimental A minor release can change the Solana badge helpers.
+ */
+declare function createSolanaBadgeMint(input: CreateSolanaBadgeMintInput): Promise<{
+    mint: Address;
+    signature: Signature;
+}>;
+/** The SPL Memo `awardSolanaBadge` attaches to a completion's mint. */
+declare const solanaBadgeMemo: (completion: string) => string;
+
+export { type AwardOwedSolanaBadgesInput, type AwardSolanaBadgeInput, type CreateSolanaBadgeMintInput, type OwedSolanaBadges, type SolanaBadgeAward, SolanaBadgePendingError, type SolanaBadgeRpc, SolanaNetwork, awardOwedSolanaBadges, awardSolanaBadge, createSolanaBadgeMint, solanaBadgeMemo, solanaBadgeReceiptKey };

package/dist/solana.js

@@ -0,0 +1,364 @@
+import {
+  maxCompletionReceipts,
+  walletLinkedEventDataSchema
+} from "./chunk-4JSPMFO2.js";
+import "./chunk-DNPDR4Z7.js";
+import "./chunk-DDJN2T5A.js";
+import "./chunk-MEUAJIVO.js";
+import "./chunk-MWMCQLCG.js";
+import "./chunk-R3MNZKNJ.js";
+import "./chunk-6UBFSMCM.js";
+import "./chunk-55WJVFWC.js";
+import {
+  paginate,
+  solanaDevnet,
+  solanaMainnet,
+  solanaMemoProgram
+} from "./chunk-6YTSRWRB.js";
+import "./chunk-IW46TW3A.js";
+
+// src/solana.ts
+import {
+  appendTransactionMessageInstructions,
+  createTransactionMessage,
+  flattenInstructionPlan,
+  getBase64EncodedWireTransaction,
+  getSignatureFromTransaction,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+  address,
+  generateKeyPairSigner
+} from "@solana/kit";
+import {
+  TOKEN_2022_PROGRAM_ADDRESS,
+  extension,
+  fetchMint,
+  findAssociatedTokenPda,
+  getCreateMintInstructionPlan,
+  getMintToATAInstructionPlan
+} from "@solana-program/token-2022";
+var solanaBadgeReceiptKey = "badge";
+async function awardSolanaBadge(input) {
+  const completion = questCompletion(input.event);
+  if (!completion || input.quests && !input.quests.includes(completion.quest)) {
+    return { status: "ignored" };
+  }
+  return awardCompletion(input, completion, badgeLookups(input));
+}
+async function awardOwedSolanaBadges(input) {
+  const { event, management } = input;
+  const linked = event.type === "wallet.linked" ? walletLinkedEventDataSchema.safeParse(event.data) : void 0;
+  if (!linked?.success || linked.data.chain !== "solana") {
+    return { status: "ignored" };
+  }
+  const { member } = linked.data;
+  const lookups = badgeLookups(input);
+  const awards = [];
+  for (const quest of input.quests ?? [void 0]) {
+    for await (const completion of paginate(
+      (cursor) => management.completions.list({ member, quest, cursor, limit: 100 })
+    )) {
+      if (completion.source?.kind !== "quest") {
+        continue;
+      }
+      awards.push({
+        completion: completion.id,
+        quest: completion.quest,
+        award: await awardCompletion(
+          input,
+          { id: completion.id, quest: completion.quest, member },
+          lookups
+        )
+      });
+    }
+  }
+  return { status: "awarded", awards };
+}
+function badgeLookups(input) {
+  const once = (read) => {
+    let value;
+    return () => value ??= read();
+  };
+  const wallets = /* @__PURE__ */ new Map();
+  return {
+    wallet(member) {
+      if (!wallets.has(member)) {
+        wallets.set(
+          member,
+          once(() => provenSolanaWallet(input.management, member))
+        );
+      }
+      return wallets.get(member)();
+    },
+    decimals: once(
+      () => badgeDecimals(input.rpc, address(input.mint), input.authority.address)
+    )
+  };
+}
+async function awardCompletion(input, completion, lookups) {
+  const { management, rpc, authority } = input;
+  let receipts = await management.completions.receipts(completion.id);
+  const existing = receipts.find(
+    (receipt) => receipt.key === solanaBadgeReceiptKey
+  );
+  if (existing) {
+    return { status: "already-minted", receipt: existing };
+  }
+  const record = (attempt2) => management.completions.recordReceipt(completion.id, {
+    key: solanaBadgeReceiptKey,
+    network: attempt2.network,
+    signature: attempt2.signature,
+    ...attempt2.asset === null ? {} : { asset: attempt2.asset },
+    ...attempt2.recipient === null ? {} : { recipient: attempt2.recipient },
+    ...input.label === void 0 ? {} : { label: input.label }
+  });
+  const settled = async () => {
+    const attempt2 = latestAttempt(receipts);
+    const outcome = attempt2 && await attemptOutcome(rpc, attempt2);
+    if (outcome === "landed") {
+      return { status: "minted", receipt: await record(attempt2) };
+    }
+    if (outcome === "pending") {
+      throw new SolanaBadgePendingError(attempt2.signature);
+    }
+    return attempt2 ? attemptNumber(attempt2.key) + 1 : 1;
+  };
+  const next = await settled();
+  if (typeof next !== "number") {
+    return next;
+  }
+  if (receipts.length >= maxCompletionReceipts - 1) {
+    throw new Error(
+      `Completion ${completion.id} holds ${receipts.length} receipts, leaving no room for another badge attempt and the badge`
+    );
+  }
+  const wallet = await lookups.wallet(completion.member);
+  if (!wallet) {
+    return { status: input.whenNoWallet === "defer" ? "deferred" : "no-wallet" };
+  }
+  const mint = address(input.mint);
+  const owner = address(wallet);
+  const decimals = await lookups.decimals();
+  const [token] = await findAssociatedTokenPda({
+    owner,
+    mint,
+    tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
+  });
+  const transaction = await sign(rpc, authority, [
+    ...instructions(
+      getMintToATAInstructionPlan({
+        payer: authority,
+        ata: token,
+        owner,
+        mint,
+        mintAuthority: authority,
+        amount: 1n,
+        decimals
+      })
+    ),
+    memoInstruction(solanaBadgeMemo(completion.id))
+  ]);
+  let attempt;
+  try {
+    attempt = await management.completions.recordReceipt(completion.id, {
+      key: `${attemptPrefix}${next}`,
+      network: input.network,
+      signature: transaction.signature,
+      asset: mint,
+      recipient: owner,
+      label: `Badge mint, valid through block height ${transaction.lastValidBlockHeight}`
+    });
+  } catch (error) {
+    if (error.code !== "receipt-conflict") {
+      throw error;
+    }
+    receipts = await management.completions.receipts(completion.id);
+    const answer = await settled();
+    if (typeof answer !== "number") {
+      return answer;
+    }
+    throw error;
+  }
+  await sendAndConfirm(rpc, transaction);
+  return { status: "minted", receipt: await record(attempt) };
+}
+var SolanaBadgePendingError = class extends Error {
+  constructor(signature) {
+    super(
+      `The badge transaction ${signature} for this completion is still confirming; try again later`
+    );
+    this.signature = signature;
+    this.name = "SolanaBadgePendingError";
+  }
+  signature;
+  code = "badge-pending";
+};
+async function createSolanaBadgeMint(input) {
+  const { authority, rpc } = input;
+  const mint = input.mint ?? await generateKeyPairSigner();
+  const plan = await getCreateMintInstructionPlan(
+    {
+      getMinimumBalance: async (space) => rpc.getMinimumBalanceForRentExemption(BigInt(space)).send()
+    },
+    {
+      payer: authority,
+      newMint: mint,
+      decimals: 0,
+      mintAuthority: authority,
+      extensions: [
+        extension("NonTransferable", {}),
+        extension("MetadataPointer", {
+          authority: authority.address,
+          metadataAddress: mint.address
+        }),
+        extension("TokenMetadata", {
+          updateAuthority: authority.address,
+          mint: mint.address,
+          name: input.name,
+          symbol: input.symbol,
+          uri: input.uri,
+          additionalMetadata: /* @__PURE__ */ new Map()
+        })
+      ]
+    }
+  );
+  const signature = await sendAndConfirm(
+    rpc,
+    await sign(rpc, authority, instructions(plan))
+  );
+  return { mint: mint.address, signature };
+}
+var solanaBadgeMemo = (completion) => `domino-badge:${completion}`;
+function questCompletion(event) {
+  const { data } = event;
+  const source = data.source;
+  const fromQuest = source === void 0 ? typeof data.attempt === "string" : source?.kind === "quest";
+  if (event.type !== "completion.created" || !fromQuest || typeof data.completion !== "string" || typeof data.quest !== "string" || typeof data.member !== "string") {
+    return null;
+  }
+  return { id: data.completion, quest: data.quest, member: data.member };
+}
+async function provenSolanaWallet(management, member) {
+  let newest;
+  for await (const identity of paginate(
+    (cursor) => management.members.identityStates.list(member, { cursor, limit: 100 })
+  )) {
+    if (identity.kind !== "wallet" || identity.chain !== "solana" || !identity.linked || identity.source === "import") {
+      continue;
+    }
+    const candidate = {
+      address: identity.address,
+      linkedAt: identity.linkedAt ?? -1,
+      revision: identity.revision
+    };
+    if (!newest || candidate.linkedAt > newest.linkedAt || candidate.linkedAt === newest.linkedAt && candidate.revision > newest.revision) {
+      newest = candidate;
+    }
+  }
+  return newest?.address;
+}
+async function badgeDecimals(rpc, mint, authority) {
+  const account = await fetchMint(rpc, mint, { commitment: "confirmed" });
+  if (account.programAddress !== TOKEN_2022_PROGRAM_ADDRESS) {
+    throw new Error(`${mint} is not a Token-2022 mint`);
+  }
+  const mintAuthority = account.data.mintAuthority;
+  if (mintAuthority.__option === "None" || mintAuthority.value !== authority) {
+    throw new Error(`${authority} is not the mint authority of ${mint}`);
+  }
+  return account.data.decimals;
+}
+var attemptPrefix = "badge-attempt-";
+var attemptNumber = (key) => Number(key.slice(attemptPrefix.length));
+function latestAttempt(receipts) {
+  return receipts.filter((receipt) => /^badge-attempt-[1-9][0-9]*$/.test(receipt.key)).sort((a, b) => attemptNumber(b.key) - attemptNumber(a.key))[0];
+}
+async function attemptOutcome(rpc, attempt) {
+  const lastValid = attempt.label?.match(/block height (\d+)$/)?.[1];
+  const height = await rpc.getBlockHeight({ commitment: "finalized" }).send();
+  const {
+    value: [status]
+  } = await rpc.getSignatureStatuses([attempt.signature], {
+    searchTransactionHistory: true
+  }).send();
+  if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
+    return status.err ? "failed" : "landed";
+  }
+  return lastValid === void 0 || height > BigInt(lastValid) ? "expired" : "pending";
+}
+var memoInstruction = (memo) => ({
+  programAddress: address(solanaMemoProgram),
+  data: new TextEncoder().encode(memo)
+});
+var instructions = (plan) => flattenInstructionPlan(plan).map((step) => {
+  if (step.kind !== "single") {
+    throw new Error("Expected a plan of single instructions");
+  }
+  return step.instruction;
+});
+async function sign(rpc, feePayer, steps) {
+  const { value: blockhash } = await rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+  const transaction = await signTransactionMessageWithSigners(
+    pipe(
+      createTransactionMessage({ version: 0 }),
+      (message) => setTransactionMessageFeePayerSigner(feePayer, message),
+      (message) => setTransactionMessageLifetimeUsingBlockhash(blockhash, message),
+      (message) => appendTransactionMessageInstructions(steps, message)
+    )
+  );
+  return {
+    wire: getBase64EncodedWireTransaction(transaction),
+    signature: getSignatureFromTransaction(transaction),
+    lastValidBlockHeight: blockhash.lastValidBlockHeight
+  };
+}
+async function sendAndConfirm(rpc, transaction) {
+  try {
+    await rpc.sendTransaction(transaction.wire, {
+      encoding: "base64",
+      preflightCommitment: "confirmed"
+    }).send();
+  } catch (error) {
+    const {
+      value: [status]
+    } = await rpc.getSignatureStatuses([transaction.signature]).send();
+    if (!status) {
+      throw error;
+    }
+  }
+  await confirmed(rpc, transaction.signature, transaction.lastValidBlockHeight);
+  return transaction.signature;
+}
+async function confirmed(rpc, signature, lastValidBlockHeight) {
+  for (; ; ) {
+    const {
+      value: [status]
+    } = await rpc.getSignatureStatuses([signature]).send();
+    if (status?.err) {
+      throw new Error(
+        `Transaction ${signature} failed: ${JSON.stringify(status.err, (_, value) => typeof value === "bigint" ? String(value) : value)}`
+      );
+    }
+    if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
+      return;
+    }
+    if (await rpc.getBlockHeight({ commitment: "confirmed" }).send() > lastValidBlockHeight) {
+      throw new Error(
+        `Transaction ${signature} was not confirmed before its blockhash expired`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+}
+export {
+  SolanaBadgePendingError,
+  awardOwedSolanaBadges,
+  awardSolanaBadge,
+  createSolanaBadgeMint,
+  solanaBadgeMemo,
+  solanaBadgeReceiptKey,
+  solanaDevnet,
+  solanaMainnet
+};

package/dist/{submission-input-ChL1aYNH.d.ts → submission-input-CaL8drIh.d.ts}

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { L as LedgerReference, Q as QuestHandle } from './tracker-data-Bl-qPIvZ.js';
-import { B as ProjectGroupReference } from './accounts-_lNsiR2k.js';
+import { L as LedgerReference, Q as QuestHandle } from './tracker-data-CAK942sx.js';
+import { B as ProjectGroupReference } from './accounts-DnpKoJCo.js';
 
 declare const completionPrerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"completion">;

package/dist/{telegram-browser-BFs4u7lC.d.ts → telegram-browser-DLtHPRBI.d.ts}

@@ -1,111 +1,9 @@
-import { c as AuthProvider, J as SignInProvider } from './accounts-_lNsiR2k.js';
-import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-Cze4lfwA.js';
-import { a as TelegramSignInMethods } from './submission-input-ChL1aYNH.js';
+import { c as AuthProvider, J as SignInProvider } from './accounts-DnpKoJCo.js';
+import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-BMif22WQ.js';
+import { a as TelegramSignInMethods } from './submission-input-CaL8drIh.js';
 import { b as ParticipantSession } from './participant-activity-DXRq4s6K.js';
-import { C as CosmosChain, a as CosmosNetwork, m as WalletSigner, k as WalletSignInNetwork } from './wallet-B7e06v4m.js';
-
-/** An EIP-1193 provider, such as `window.ethereum` or an EIP-6963 announcement's provider. */
-type Eip1193Provider = {
-    request(args: {
-        method: string;
-        params?: unknown[] | object;
-    }): Promise<unknown>;
-    /** Subscribes to a provider event such as `accountsChanged`; wallets without events leave it out. */
-    on?(event: string, listener: (...args: unknown[]) => void): unknown;
-    removeListener?(event: string, listener: (...args: unknown[]) => void): unknown;
-};
-/** The legacy injected Solana shape Phantom, Solflare and Backpack expose. */
-type SolanaInjectedProvider = {
-    connect(): Promise<unknown>;
-    publicKey?: {
-        toBase58(): string;
-    } | null;
-    signMessage(message: Uint8Array, display?: "utf8"): Promise<{
-        signature: Uint8Array;
-    } | Uint8Array>;
-};
-/** The part of a Wallet Standard account Relay uses. */
-type StandardWalletAccount = {
-    readonly address: string;
-    readonly chains: readonly string[];
-};
-/** The part of a Wallet Standard wallet Relay uses; any conforming wallet object fits. */
-type StandardWallet = {
-    readonly name: string;
-    readonly icon?: string;
-    readonly chains: readonly string[];
-    readonly accounts: readonly StandardWalletAccount[];
-    readonly features: Readonly<Record<string, unknown>>;
-};
-/** Keplr's API, which Leap and Cosmostation also implement. */
-type KeplrLike = {
-    enable(chainId: string | string[]): Promise<void>;
-    getKey(chainId: string): Promise<{
-        bech32Address: string;
-    }>;
-    signArbitrary(chainId: string, signer: string, data: string): Promise<{
-        signature: string;
-        pub_key: {
-            type: string;
-            value: string;
-        };
-    }>;
-    /** Adds a chain the wallet does not know, after the user approves it. */
-    experimentalSuggestChain?(chainInfo: CosmosChain["chainInfo"]): Promise<void>;
-};
-/** A wallet found in the page, ready to pass to `relay.wallets.link`. */
-type DiscoveredWallet = {
-    id: string;
-    name: string;
-    icon?: string;
-    signer: WalletSigner;
-};
-/** Signs with an EIP-1193 provider through `personal_sign`. */
-declare function evmSigner(provider: Eip1193Provider, info?: {
-    name?: string;
-}): WalletSigner;
-/** Signs with a legacy injected Solana provider, such as `window.phantom.solana`. */
-declare function solanaSigner(provider: SolanaInjectedProvider, info?: {
-    name?: string;
-}): WalletSigner;
-/** Signs with a Wallet Standard wallet's `solana:signMessage` feature. */
-declare function walletStandardSolanaSigner(wallet: StandardWallet): WalletSigner;
-/**
- * Signs an ADR-36 message with Keplr or a wallet that implements its API, on the app's chain:
- * `{ chainId, chainInfo? }` or `"cosmos:<chain ID>"`. When the wallet does not know the chain and
- * `chainInfo` is given, it suggests the chain to the wallet (`experimentalSuggestChain`) and tries
- * again; without `chainInfo`, or with a wallet that cannot add chains, it throws an error that
- * names the chain. Other failures, such as a rejected request, pass through.
- */
-declare function cosmosSigner(provider: KeplrLike, chain: CosmosChain | CosmosNetwork, info?: {
-    name?: string;
-}): WalletSigner;
-/** EIP-6963 wallets, or `window.ethereum` when none announce themselves within `timeoutMs`. */
-declare function discoverEvmWallets(timeoutMs?: number): Promise<DiscoveredWallet[]>;
-/** Wallet Standard wallets that can sign Solana messages, then legacy injected providers. */
-declare function discoverSolanaWallets(): DiscoveredWallet[];
-/**
- * Keplr, Leap and Cosmostation, each signing on the app's chain (see `cosmosSigner`). IDs end with
- * the chain ID.
- */
-declare function discoverCosmosWallets(chain: CosmosChain | CosmosNetwork): DiscoveredWallet[];
-/**
- * The Cosmos SDK chains an app offers wallets on: one chain or several, each as
- * `{ chainId, chainInfo? }` or `"cosmos:<chain ID>"`. Relay has no chain list of its own.
- */
-type CosmosChains = CosmosChain | CosmosNetwork | readonly (CosmosChain | CosmosNetwork)[];
-/** The chains in `CosmosChains`, as a list. */
-declare function cosmosChainList(chains: CosmosChains | undefined): (CosmosChain | CosmosNetwork)[];
-/** An installed wallet that can sign in on one of the project's enabled wallet families. */
-type SignInWallet = DiscoveredWallet & {
-    network: WalletSignInNetwork;
-};
-/**
- * The wallets installed in this browser that can sign in with `families`: EVM wallets first, then
- * Solana wallets, then Cosmos wallets once per chain in `cosmos`. Without `cosmos` there are no
- * Cosmos wallets. Empty during SSR.
- */
-declare function discoverSignInWallets(families: readonly WalletSignInNetwork[], cosmos?: CosmosChains): Promise<SignInWallet[]>;
+import { m as WalletSignInNetwork, o as WalletSigner } from './wallet-DQtJelQQ.js';
+import { C as CosmosChains } from './wallet-browser-dpmr22Xv.js';
 
 type Auth = ReturnType<typeof createRelayClient>["auth"];
 /**
@@ -286,4 +184,4 @@ declare function signInOptions(relay: SignInClient, input?: {
  */
 declare function telegramMiniAppInitData(): string | null;
 
-export { type CosmosChains as C, type DiscoveredWallet as D, type Eip1193Provider as E, type KeplrLike as K, type OAuthSignInOption as O, type ProviderSignInOption as P, type SignInClient as S, type TelegramSignInOption as T, type WalletSignInOption as W, type EmailSignInOption as a, type SignInIcon as b, type SignInMethods as c, type SignInOption as d, type SignInOptions as e, type SignInUnavailable as f, type SignInWallet as g, type SolanaInjectedProvider as h, type StandardWallet as i, type StandardWalletAccount as j, cosmosChainList as k, cosmosSigner as l, discoverCosmosWallets as m, discoverEvmWallets as n, discoverSignInWallets as o, discoverSolanaWallets as p, evmSigner as q, solanaSigner as r, signInOptions as s, telegramMiniAppInitData as t, walletStandardSolanaSigner as w };
+export { type EmailSignInOption as E, type OAuthSignInOption as O, type ProviderSignInOption as P, type SignInClient as S, type TelegramSignInOption as T, type WalletSignInOption as W, type SignInIcon as a, type SignInMethods as b, type SignInOption as c, type SignInOptions as d, type SignInUnavailable as e, signInOptions as s, telegramMiniAppInitData as t };