@domino-sdk/relay 1.67.0 → 1.69.0

package/dist/solana.js

@@ -0,0 +1,699 @@
+import {
+  maxCompletionReceipts,
+  walletLinkedEventDataSchema
+} from "./chunk-WNEQEDMU.js";
+import "./chunk-ODJGTFPY.js";
+import "./chunk-DIXYVGXO.js";
+import "./chunk-CZ23KRVK.js";
+import "./chunk-MWMCQLCG.js";
+import "./chunk-ME2KUAVJ.js";
+import "./chunk-PO2ZDY27.js";
+import "./chunk-2A3BJ262.js";
+import {
+  paginate,
+  solanaDevnet,
+  solanaMainnet,
+  solanaMemoProgram
+} 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,
+  flattenInstructionPlan,
+  getBase64EncodedWireTransaction,
+  getSignatureFromTransaction,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+  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 {
+  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);
+  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)();
+    },
+    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) {
+  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 = 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);
+    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 owner = address3(wallet);
+  const transaction = await sign(rpc, authority, [
+    ...await lookups.minter.instructions(owner),
+    memoInstruction(solanaBadgeMemo(completion.id))
+  ]);
+  let attempt;
+  try {
+    attempt = await management.completions.recordReceipt(completion.id, {
+      key: `${attemptPrefix}${next}`,
+      network: input.network,
+      signature: transaction.signature,
+      // 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}`
+    });
+  } 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 generateKeyPairSigner2();
+  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";
+}
+export {
+  SolanaBadgePendingError,
+  awardOwedSolanaBadges,
+  awardSolanaBadge,
+  createSolanaBadgeMint,
+  createSolanaBadgeTree,
+  solanaBadgeMemo,
+  solanaBadgeReceiptKey,
+  solanaDevnet,
+  solanaMainnet
+};

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 };