@domino-sdk/relay 1.68.0 → 1.69.0

package/dist/solana.js

@@ -1,23 +1,37 @@
 import {
   maxCompletionReceipts,
   walletLinkedEventDataSchema
-} from "./chunk-4JSPMFO2.js";
-import "./chunk-DNPDR4Z7.js";
-import "./chunk-DDJN2T5A.js";
-import "./chunk-MEUAJIVO.js";
+} from "./chunk-WNEQEDMU.js";
+import "./chunk-ODJGTFPY.js";
+import "./chunk-DIXYVGXO.js";
+import "./chunk-CZ23KRVK.js";
 import "./chunk-MWMCQLCG.js";
-import "./chunk-R3MNZKNJ.js";
-import "./chunk-6UBFSMCM.js";
-import "./chunk-55WJVFWC.js";
+import "./chunk-ME2KUAVJ.js";
+import "./chunk-PO2ZDY27.js";
+import "./chunk-2A3BJ262.js";
 import {
   paginate,
   solanaDevnet,
   solanaMainnet,
   solanaMemoProgram
-} from "./chunk-6YTSRWRB.js";
-import "./chunk-IW46TW3A.js";
+} from "./chunk-CQVKOD3B.js";
+import "./chunk-VNEJH4NT.js";
 
 // src/solana.ts
+import {
+  address as address3,
+  generateKeyPairSigner as generateKeyPairSigner2
+} from "@solana/kit";
+import {
+  TOKEN_2022_PROGRAM_ADDRESS,
+  extension,
+  fetchMint,
+  findAssociatedTokenPda,
+  getCreateMintInstructionPlan,
+  getMintToATAInstructionPlan
+} from "@solana-program/token-2022";
+
+// src/solana-badge-transactions.ts
 import {
   appendTransactionMessageInstructions,
   createTransactionMessage,
@@ -28,17 +42,388 @@ import {
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
   signTransactionMessageWithSigners,
-  address,
-  generateKeyPairSigner
+  address
 } from "@solana/kit";
+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));
+  }
+}
+
+// src/solana-compressed-badges.ts
 import {
-  TOKEN_2022_PROGRAM_ADDRESS,
-  extension,
-  fetchMint,
-  findAssociatedTokenPda,
-  getCreateMintInstructionPlan,
-  getMintToATAInstructionPlan
-} from "@solana-program/token-2022";
+  AccountRole,
+  addEncoderSizePrefix,
+  getAddressDecoder,
+  getAddressEncoder,
+  getArrayEncoder,
+  getBase58Encoder,
+  getBooleanEncoder,
+  getBytesEncoder,
+  fixEncoderSize,
+  getNullableEncoder,
+  getProgramDerivedAddress,
+  getStructEncoder,
+  getU16Encoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Encoder,
+  getUtf8Encoder,
+  address as address2,
+  decimalFixedPointToString,
+  fetchEncodedAccount,
+  generateKeyPairSigner,
+  lamports as toLamports,
+  lamportsToSol
+} from "@solana/kit";
+var bubblegumProgram = /* @__PURE__ */ (() => address2("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY"))();
+var coreProgram = /* @__PURE__ */ (() => address2("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d"))();
+var compressionProgram = /* @__PURE__ */ (() => address2(
+  "mcmt6YrQEMKw8Mw43FmpRLmf7BqRnFMKmAcbxE3xkAW"
+))();
+var noopProgram = /* @__PURE__ */ (() => address2("mnoopTCrg4p8ry25e4bcWA9XZjbNjMTfgYVGGEdRsf3"))();
+var systemProgram = /* @__PURE__ */ (() => address2("11111111111111111111111111111111"))();
+var coreCpiSigner = /* @__PURE__ */ (() => address2("CbNY3JiXdXNE9tPNEk1aRZVEkWdj2v7kfJLNQwZZgpXk"))();
+var string = () => addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder());
+var treeVersion2 = 1;
+var coreCollectionKey = 5;
+var discriminator = () => fixEncoderSize(getBytesEncoder(), 8);
+var readonly = (account) => ({
+  address: account,
+  role: AccountRole.READONLY
+});
+var writable = (account) => ({
+  address: account,
+  role: AccountRole.WRITABLE
+});
+var signing = (signer, role) => ({
+  address: signer.address,
+  role,
+  signer
+});
+var treeConfigAddress = async (tree) => (await getProgramDerivedAddress({
+  programAddress: bubblegumProgram,
+  seeds: [getAddressEncoder().encode(tree)]
+}))[0];
+var mintV2Data = /* @__PURE__ */ (() => getStructEncoder([
+  ["discriminator", discriminator()],
+  ["name", string()],
+  ["symbol", string()],
+  ["uri", string()],
+  ["sellerFeeBasisPoints", getU16Encoder()],
+  ["primarySaleHappened", getBooleanEncoder()],
+  ["isMutable", getBooleanEncoder()],
+  ["tokenStandard", getNullableEncoder(getU8Encoder())],
+  ["creators", getArrayEncoder(getU8Encoder())],
+  ["collection", getNullableEncoder(getAddressEncoder())],
+  ["assetData", getNullableEncoder(getU8Encoder())],
+  ["assetDataSchema", getNullableEncoder(getU8Encoder())]
+]))();
+async function mintV2(badge, authority, owner) {
+  const tree = address2(badge.tree);
+  const collection = address2(badge.collection);
+  return {
+    programAddress: bubblegumProgram,
+    accounts: [
+      writable(await treeConfigAddress(tree)),
+      signing(authority, AccountRole.WRITABLE_SIGNER),
+      signing(authority, AccountRole.READONLY_SIGNER),
+      signing(authority, AccountRole.READONLY_SIGNER),
+      readonly(owner),
+      readonly(owner),
+      writable(tree),
+      writable(collection),
+      readonly(coreCpiSigner),
+      readonly(noopProgram),
+      readonly(compressionProgram),
+      readonly(coreProgram),
+      readonly(systemProgram)
+    ],
+    data: mintV2Data.encode({
+      discriminator: Uint8Array.of(120, 121, 23, 146, 173, 110, 199, 205),
+      name: badge.metadata.name,
+      symbol: badge.metadata.symbol ?? "",
+      uri: badge.metadata.uri,
+      // No royalties: badges are not sold.
+      sellerFeeBasisPoints: 0,
+      primarySaleHappened: false,
+      isMutable: true,
+      // TokenStandard::NonFungible, the one Bubblegum accepts.
+      tokenStandard: 0,
+      creators: [],
+      collection,
+      assetData: null,
+      assetDataSchema: null
+    })
+  };
+}
+async function checkCompressedBadge(rpc, badge, authority) {
+  const tree = address2(badge.tree);
+  const collection = address2(badge.collection);
+  const read = (account) => fetchEncodedAccount(rpc, account, { commitment: "confirmed" });
+  const [config, core] = await Promise.all([
+    read(await treeConfigAddress(tree)),
+    read(collection)
+  ]);
+  if (!config.exists || config.programAddress !== bubblegumProgram || config.data.length < 91 || config.data[90] !== treeVersion2) {
+    throw new Error(`${tree} is not a Bubblegum v2 tree`);
+  }
+  if (getAddressDecoder().decode(config.data, 8) !== authority && getAddressDecoder().decode(config.data, 40) !== authority && config.data[88] !== 1) {
+    throw new Error(
+      `${authority} is neither the creator nor the delegate of ${tree}`
+    );
+  }
+  const capacity = getU64Decoder().decode(config.data, 72);
+  if (getU64Decoder().decode(config.data, 80) >= capacity) {
+    throw new Error(`${tree} is full: it holds ${capacity} badges`);
+  }
+  if (!core.exists || core.programAddress !== coreProgram || core.data[0] !== coreCollectionKey) {
+    throw new Error(`${collection} is not a Core collection`);
+  }
+  if (getAddressDecoder().decode(core.data, 1) !== authority) {
+    throw new Error(`${authority} is not the update authority of ${collection}`);
+  }
+}
+function compressedBadgeMinter(input) {
+  return {
+    async instructions(owner) {
+      await checkCompressedBadge(
+        input.rpc,
+        input.badge,
+        input.authority.address
+      );
+      return [await mintV2(input.badge, input.authority, owner)];
+    },
+    async asset(signature) {
+      for (let read = 1; ; read++) {
+        const asset = await mintedAsset(input.rpc, signature);
+        if (asset !== null || read === 5) {
+          return asset;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+  };
+}
+async function mintedAsset(rpc, signature) {
+  const transaction = await rpc.getTransaction(signature, {
+    commitment: "confirmed",
+    encoding: "json",
+    maxSupportedTransactionVersion: 0
+  }).send();
+  if (!transaction) {
+    return null;
+  }
+  const keys = transaction.transaction.message.accountKeys;
+  const outer = transaction.transaction.message.instructions.findIndex(
+    (instruction) => keys[instruction.programIdIndex] === bubblegumProgram
+  );
+  const logged = transaction.meta?.innerInstructions?.find((group) => group.index === outer)?.instructions.map((instruction) => ({
+    program: keys[instruction.programIdIndex],
+    data: getBase58Encoder().encode(instruction.data)
+  })).find(
+    ({ program, data }) => program === noopProgram && data.length >= 41 && data[0] === 1 && data[1] === 0 && data[6] === 1 && data[7] === 1 && data[8] === 1
+  );
+  if (!logged) {
+    throw new Error(`Transaction ${signature} minted no compressed NFT`);
+  }
+  return getAddressDecoder().decode(logged.data, 9);
+}
+async function createSolanaBadgeTree(input) {
+  const { authority, rpc, maxDepth, maxBufferSize } = input;
+  const tree = input.tree ?? await generateKeyPairSigner();
+  const collection = input.collectionKey ?? await generateKeyPairSigner();
+  const soulbound = !input.collection.transferable;
+  const treeBytes = merkleTreeSize(maxDepth, maxBufferSize);
+  const collectionBytes = coreCollectionSize(input.collection, soulbound);
+  const rents = await Promise.all(
+    [treeBytes, treeConfigSize, collectionBytes].map(
+      (size) => rpc.getMinimumBalanceForRentExemption(BigInt(size)).send()
+    )
+  );
+  const lamports = toLamports(rents.reduce((sum, rent2) => sum + rent2, 0n));
+  const rent = {
+    lamports,
+    sol: decimalFixedPointToString(lamportsToSol(lamports)),
+    capacity: 2 ** maxDepth,
+    treeBytes
+  };
+  const confirm = input.confirmRent ?? ((cost) => {
+    console.info(
+      `Creating a badge tree for ${cost.capacity} badges and its collection costs ${cost.sol} SOL in rent (${cost.lamports} lamports)`
+    );
+    return true;
+  });
+  if (!await confirm(rent)) {
+    throw new Error("Badge tree creation was not confirmed; nothing was sent");
+  }
+  const signature = await sendAndConfirm(
+    rpc,
+    await sign(rpc, authority, [
+      createAccount(authority, tree, rents[0], treeBytes, compressionProgram),
+      await createTreeV2(authority, tree.address, maxDepth, maxBufferSize),
+      createCollectionV2(authority, collection, input.collection, soulbound)
+    ])
+  );
+  return { tree: tree.address, collection: collection.address, signature };
+}
+var merkleTreeSize = (maxDepth, maxBufferSize) => 1 + (1 + 4 + 4 + 32 + 8 + 1 + 5) + 8 * 3 + maxBufferSize * (32 + 32 * maxDepth + 8) + (32 * maxDepth + 32 + 8);
+var treeConfigSize = 8 + 32 + 32 + 8 + 8 + 1 + 1 + 1 + 5;
+var coreCollectionSize = (collection, soulbound) => {
+  const utf8 = (text) => new TextEncoder().encode(text).length;
+  const base = 1 + 32 + 4 + utf8(collection.name) + 4 + utf8(collection.uri) + 8;
+  let plugins = 1;
+  let records = 1 + 33 + 8;
+  if (soulbound) {
+    plugins += 1 + 1;
+    records += 1 + 1 + 8;
+  }
+  return base + (1 + 8) + plugins + (1 + 4 + records + 4);
+};
+function createAccount(payer, account, lamports, space, owner) {
+  return {
+    programAddress: systemProgram,
+    accounts: [
+      signing(payer, AccountRole.WRITABLE_SIGNER),
+      signing(account, AccountRole.WRITABLE_SIGNER)
+    ],
+    data: getStructEncoder([
+      ["instruction", getU32Encoder()],
+      ["lamports", getU64Encoder()],
+      ["space", getU64Encoder()],
+      ["owner", getAddressEncoder()]
+    ]).encode({ instruction: 0, lamports, space, owner })
+  };
+}
+async function createTreeV2(authority, tree, maxDepth, maxBufferSize) {
+  return {
+    programAddress: bubblegumProgram,
+    accounts: [
+      writable(await treeConfigAddress(tree)),
+      writable(tree),
+      signing(authority, AccountRole.WRITABLE_SIGNER),
+      signing(authority, AccountRole.READONLY_SIGNER),
+      readonly(noopProgram),
+      readonly(compressionProgram),
+      readonly(systemProgram)
+    ],
+    data: getStructEncoder([
+      ["discriminator", discriminator()],
+      ["maxDepth", getU32Encoder()],
+      ["maxBufferSize", getU32Encoder()],
+      ["public", getNullableEncoder(getBooleanEncoder())]
+    ]).encode({
+      discriminator: Uint8Array.of(55, 99, 95, 215, 142, 203, 227, 205),
+      maxDepth,
+      maxBufferSize,
+      public: false
+    })
+  };
+}
+var corePlugin = { permanentFreezeDelegate: 5, bubblegumV2: 15 };
+var corePluginAuthority = { none: 0 };
+function createCollectionV2(authority, collection, details, soulbound) {
+  const plugins = [
+    Uint8Array.of(corePlugin.bubblegumV2, 0),
+    ...soulbound ? [
+      Uint8Array.of(
+        corePlugin.permanentFreezeDelegate,
+        1,
+        // frozen
+        1,
+        // Some(
+        corePluginAuthority.none
+      )
+    ] : []
+  ];
+  return {
+    programAddress: coreProgram,
+    accounts: [
+      signing(collection, AccountRole.WRITABLE_SIGNER),
+      readonly(authority.address),
+      signing(authority, AccountRole.WRITABLE_SIGNER),
+      readonly(systemProgram)
+    ],
+    data: getStructEncoder([
+      ["instruction", getU8Encoder()],
+      ["name", string()],
+      ["uri", string()],
+      ["plugins", getNullableEncoder(getArrayEncoder(getBytesEncoder()))],
+      [
+        "externalPluginAdapters",
+        getNullableEncoder(getArrayEncoder(getU8Encoder()))
+      ]
+    ]).encode({
+      instruction: 21,
+      name: details.name,
+      uri: details.uri,
+      plugins,
+      externalPluginAdapters: []
+    })
+  };
+}
+
+// src/solana.ts
 var solanaBadgeReceiptKey = "badge";
 async function awardSolanaBadge(input) {
   const completion = questCompletion(input.event);
@@ -92,9 +477,32 @@ function badgeLookups(input) {
       }
       return wallets.get(member)();
     },
-    decimals: once(
-      () => badgeDecimals(input.rpc, address(input.mint), input.authority.address)
-    )
+    minter: input.badge ? compressedBadgeMinter({ ...input, badge: input.badge }) : tokenBadgeMinter(input, address3(input.mint))
+  };
+}
+function tokenBadgeMinter(input, mint) {
+  let decimals;
+  return {
+    async instructions(owner) {
+      decimals ??= badgeDecimals(input.rpc, mint, input.authority.address);
+      const [token] = await findAssociatedTokenPda({
+        owner,
+        mint,
+        tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
+      });
+      return instructions(
+        getMintToATAInstructionPlan({
+          payer: input.authority,
+          ata: token,
+          owner,
+          mint,
+          mintAuthority: input.authority,
+          amount: 1n,
+          decimals: await decimals
+        })
+      );
+    },
+    asset: async () => mint
   };
 }
 async function awardCompletion(input, completion, lookups) {
@@ -106,14 +514,20 @@ async function awardCompletion(input, completion, lookups) {
   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 record = async (attempt2) => {
+    const asset = await lookups.minter.asset(attempt2.signature);
+    if (asset === null) {
+      throw new SolanaBadgePendingError(attempt2.signature);
+    }
+    return management.completions.recordReceipt(completion.id, {
+      key: solanaBadgeReceiptKey,
+      network: attempt2.network,
+      signature: attempt2.signature,
+      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);
@@ -138,26 +552,9 @@ async function awardCompletion(input, completion, lookups) {
   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 owner = address3(wallet);
   const transaction = await sign(rpc, authority, [
-    ...instructions(
-      getMintToATAInstructionPlan({
-        payer: authority,
-        ata: token,
-        owner,
-        mint,
-        mintAuthority: authority,
-        amount: 1n,
-        decimals
-      })
-    ),
+    ...await lookups.minter.instructions(owner),
     memoInstruction(solanaBadgeMemo(completion.id))
   ]);
   let attempt;
@@ -166,7 +563,8 @@ async function awardCompletion(input, completion, lookups) {
       key: `${attemptPrefix}${next}`,
       network: input.network,
       signature: transaction.signature,
-      asset: mint,
+      // A compressed badge's asset ID is known once its mint lands.
+      ...input.mint === void 0 ? {} : { asset: input.mint },
       recipient: owner,
       label: `Badge mint, valid through block height ${transaction.lastValidBlockHeight}`
     });
@@ -197,7 +595,7 @@ var SolanaBadgePendingError = class extends Error {
 };
 async function createSolanaBadgeMint(input) {
   const { authority, rpc } = input;
-  const mint = input.mint ?? await generateKeyPairSigner();
+  const mint = input.mint ?? await generateKeyPairSigner2();
   const plan = await getCreateMintInstructionPlan(
     {
       getMinimumBalance: async (space) => rpc.getMinimumBalanceForRentExemption(BigInt(space)).send()
@@ -288,75 +686,12 @@ async function attemptOutcome(rpc, attempt) {
   }
   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,
+  createSolanaBadgeTree,
   solanaBadgeMemo,
   solanaBadgeReceiptKey,
   solanaDevnet,

package/dist/{streaks-0YuipsUQ.d.ts → streaks-MAqKHbHC.d.ts}

@@ -68,4 +68,5 @@ declare const streakProgressSchema: z.ZodObject<{
 }, z.core.$strip>;
 type StreakProgress = z.infer<typeof streakProgressSchema>;
 
-export { type QuizContent as Q, type StreakProgress as S, type StreakPolicy as a, quizContentSchema as b, quizQuestionSchema as c, quizQuestionsSchema as d, streakProgressSchema as e, quizChoiceSchema as q, streakPolicySchema as s };
+export { quizContentSchema as b, quizQuestionSchema as c, quizQuestionsSchema as d, streakProgressSchema as e, quizChoiceSchema as q, streakPolicySchema as s };
+export type { QuizContent as Q, StreakProgress as S, StreakPolicy as a };

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

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { L as LedgerReference, Q as QuestHandle } from './tracker-data-CAK942sx.js';
-import { B as ProjectGroupReference } from './accounts-DnpKoJCo.js';
+import { L as LedgerReference, Q as QuestHandle } from './tracker-data-DQgX3FIc.js';
+import { B as ProjectGroupReference } from './accounts-DD4gAOCe.js';
 
 declare const completionPrerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"completion">;
@@ -340,4 +340,5 @@ declare function validateSubmissionValue(input: ValueEvidence, contract: {
 /** Extract an ID only. The URL and its author name are untrusted claims. */
 declare function xPostId(value: string): string | null;
 
-export { telegramChatsSchema as A, telegramConnectionInputSchema as B, telegramConnectionSchema as C, telegramInitDataSchema as D, telegramMemberInputSchema as E, telegramMessageDataSchema as F, telegramMiniAppSignInSchema as G, telegramReactionDataSchema as H, telegramSignInMethodsSchema as I, textEvidenceSchema as J, textOptionsSchema as K, urlEvidenceSchema as L, type MissingPrerequisite as M, urlOptionsSchema as N, validateSubmissionValue as O, type Prerequisite as P, valueEvidenceSchema as Q, xPostId as R, type TelegramAccountConnection as T, type UrlEvidence as U, type ValueEvidence as V, type TelegramSignInMethods as a, type TextEvidence as b, type TextOptions as c, type UrlOptions as d, type TelegramReader as e, type TelegramChatMember as f, type TelegramChatMemberStatus as g, type TelegramConnection as h, type TelegramMessageData as i, type TelegramReactionData as j, balanceAtLeast as k, completed as l, inGroup as m, type TelegramChat as n, type TelegramChatConnection as o, type TelegramChats as p, balancePrerequisiteSchema as q, completionPrerequisiteSchema as r, groupPrerequisiteSchema as s, missingPrerequisiteSchema as t, prerequisiteSchema as u, telegramAccountConnectionSchema as v, telegramChatConnectionSchema as w, telegramChatIdSchema as x, telegramChatMemberSchema as y, telegramChatSchema as z };
+export { telegramChatsSchema as A, telegramConnectionInputSchema as B, telegramConnectionSchema as C, telegramInitDataSchema as D, telegramMemberInputSchema as E, telegramMessageDataSchema as F, telegramMiniAppSignInSchema as G, telegramReactionDataSchema as H, telegramSignInMethodsSchema as I, textEvidenceSchema as J, textOptionsSchema as K, urlEvidenceSchema as L, urlOptionsSchema as N, validateSubmissionValue as O, valueEvidenceSchema as Q, xPostId as R, balanceAtLeast as k, completed as l, inGroup as m, balancePrerequisiteSchema as q, completionPrerequisiteSchema as r, groupPrerequisiteSchema as s, missingPrerequisiteSchema as t, prerequisiteSchema as u, telegramAccountConnectionSchema as v, telegramChatConnectionSchema as w, telegramChatIdSchema as x, telegramChatMemberSchema as y, telegramChatSchema as z };
+export type { MissingPrerequisite as M, Prerequisite as P, TelegramAccountConnection as T, UrlEvidence as U, ValueEvidence as V, TelegramSignInMethods as a, TextEvidence as b, TextOptions as c, UrlOptions as d, TelegramReader as e, TelegramChatMember as f, TelegramChatMemberStatus as g, TelegramConnection as h, TelegramMessageData as i, TelegramReactionData as j, TelegramChat as n, TelegramChatConnection as o, TelegramChats as p };

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

@@ -1,9 +1,9 @@
-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 { m as WalletSignInNetwork, o as WalletSigner } from './wallet-DQtJelQQ.js';
-import { C as CosmosChains } from './wallet-browser-dpmr22Xv.js';
+import { c as AuthProvider, J as SignInProvider } from './accounts-DD4gAOCe.js';
+import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-6eSYOl8h.js';
+import { a as TelegramSignInMethods } from './submission-input-BD7nORuh.js';
+import { b as ParticipantSession } from './participant-activity-BznrcePT.js';
+import { e as WalletSignInNetwork, g as WalletSigner } from './wallet-CPAjrW4k.js';
+import { C as CosmosChains } from './wallet-browser-BzPt_Qb5.js';
 
 type Auth = ReturnType<typeof createRelayClient>["auth"];
 /**
@@ -184,4 +184,5 @@ declare function signInOptions(relay: SignInClient, input?: {
  */
 declare function telegramMiniAppInitData(): string | null;
 
-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 };
+export { signInOptions as s, telegramMiniAppInitData as t };
+export type { EmailSignInOption as E, OAuthSignInOption as O, ProviderSignInOption as P, SignInClient as S, TelegramSignInOption as T, WalletSignInOption as W, SignInIcon as a, SignInMethods as b, SignInOption as c, SignInOptions as d, SignInUnavailable as e };