@provable-games/budokan-sdk 0.1.24 → 0.1.26

package/dist/index.js

@@ -209,11 +209,37 @@ function camelToSnake(obj) {
   return obj;
 }
 
+// src/phase/index.ts
+function tournamentPhase(t, nowSeconds) {
+  const createdAt = Number(t.createdAtOnchain ?? NaN);
+  if (!Number.isFinite(createdAt)) return null;
+  const regStartDelay = Number(t.registrationStartDelay ?? t.schedule?.registrationStartDelay ?? 0);
+  const regEndDelay = Number(t.registrationEndDelay ?? t.schedule?.registrationEndDelay ?? 0);
+  const gameStartDelay = Number(t.gameStartDelay ?? t.schedule?.gameStartDelay ?? 0);
+  const gameEndDelay = Number(t.gameEndDelay ?? t.schedule?.gameEndDelay ?? 0);
+  const submissionDuration = Number(t.submissionDuration ?? t.schedule?.submissionDuration ?? 0);
+  const now = nowSeconds ?? Math.floor(Date.now() / 1e3);
+  const hasReg = regStartDelay > 0 || regEndDelay > 0;
+  const regStart = createdAt + regStartDelay;
+  const regEnd = regStart + regEndDelay;
+  const gameStart = createdAt + gameStartDelay;
+  const gameEnd = gameStart + gameEndDelay;
+  const subEnd = gameEnd + submissionDuration;
+  if (hasReg && now < regStart) return "scheduled";
+  if (hasReg && now < regEnd) return "registration";
+  if (now < gameStart) return "staging";
+  if (now < gameEnd) return "live";
+  if (now < subEnd) return "submission";
+  return "finalized";
+}
+
 // src/api/tournaments.ts
 function normalizeTournament(raw) {
   const t = snakeToCamel(raw);
   const id = t.id ?? t.tournamentId;
-  return { ...t, id, tournamentId: id };
+  const protocolFeeShare = t.protocolFeeShare ?? t.entryFee?.protocolFeeShare ?? null;
+  const phase = t.phase ?? tournamentPhase(t);
+  return { ...t, id, tournamentId: id, protocolFeeShare, phase };
 }
 function fetchOpts(ctx) {
   return {
@@ -538,7 +564,7 @@ var WSManager = class {
 // src/chains/constants.ts
 var CHAINS = {
   mainnet: {
-    rpcUrl: "https://api.cartridge.gg/x/starknet/mainnet/rpc/v0_10",
+    rpcUrl: "https://rpc.provable.games/rpc",
     apiBaseUrl: "https://budokan-api-production.up.railway.app",
     wsUrl: "wss://budokan-api-production.up.railway.app/ws",
     budokanAddress: "0x0596ced030e74ebc37f33607f07ecd5a62eff22cdc4ae31fe2d724040c1bdc0b",
@@ -830,7 +856,7 @@ function phaseToRpcArg(phase) {
   }
   return new CairoCustomEnum(variants);
 }
-function parseTournament(raw, entryCount) {
+function parseTournament(raw, entryCount, protocolFeeShare = null) {
   const obj = raw;
   const id = String(obj.id ?? "0");
   const createdAt = Number(obj.created_at ?? 0);
@@ -928,6 +954,8 @@ function parseTournament(raw, entryCount) {
     leaderboardGameMustBeOver: gameMustBeOver,
     entryFeeToken,
     entryFeeAmount,
+    // Protocol-fee bps snapshot, surfaced by the viewer's TournamentFullState.
+    protocolFeeShare,
     hasEntryRequirement,
     schedule: {
       registrationStartDelay,
@@ -949,6 +977,14 @@ function parseTournament(raw, entryCount) {
     entryFeeExtension,
     entryRequirement,
     leaderboardConfig: { ascending, gameMustBeOver },
+    phase: tournamentPhase({
+      createdAtOnchain: createdAtStr,
+      registrationStartDelay,
+      registrationEndDelay,
+      gameStartDelay,
+      gameEndDelay,
+      submissionDuration
+    }),
     entryCount,
     prizeCount: 0,
     // Not available from viewer
@@ -1094,7 +1130,8 @@ function parseFilterResult(raw) {
 function parseTournamentFullState(raw) {
   const obj = raw;
   const entryCount = Number(obj.entry_count ?? 0);
-  return parseTournament(obj.tournament, entryCount);
+  const protocolFeeShare = obj.protocol_fee_bps != null ? Number(obj.protocol_fee_bps) : null;
+  return parseTournament(obj.tournament, entryCount, protocolFeeShare);
 }
 async function viewerTournaments(contract, offset, limit) {
   return wrapRpcCall(async () => {
@@ -1270,6 +1307,9 @@ function translateCairoRewardType(rewardType) {
     if (subVariant === "GameCreator" || subBag?.GameCreator !== void 0) {
       return rewardClaim({ claimKind: "entry_fee_game_creator" });
     }
+    if (subVariant === "ProtocolFee" || subBag?.ProtocolFee !== void 0) {
+      return rewardClaim({ claimKind: "entry_fee_protocol_fee" });
+    }
     if (subVariant === "Refund" || subBag?.Refund !== void 0) {
       return rewardClaim({
         claimKind: "entry_fee_refund",
@@ -1742,6 +1782,10 @@ var budokanViewer_default = [
       {
         name: "phase",
         type: "budokan_interfaces::budokan::Phase"
+      },
+      {
+        name: "protocol_fee_bps",
+        type: "core::integer::u16"
       }
     ]
   },
@@ -2012,6 +2056,10 @@ var budokanViewer_default = [
       {
         name: "Refund",
         type: "core::felt252"
+      },
+      {
+        name: "ProtocolFee",
+        type: "()"
       }
     ]
   },
@@ -3390,6 +3438,10 @@ var budokan_default = [
       {
         name: "Refund",
         type: "core::felt252"
+      },
+      {
+        name: "ProtocolFee",
+        type: "()"
       }
     ]
   },
@@ -4678,6 +4730,11 @@ var budokan_default = [
         name: "entry_requirement",
         type: "core::option::Option::<game_components_interfaces::entry_requirement::EntryRequirement>",
         kind: "data"
+      },
+      {
+        name: "protocol_fee_bps",
+        type: "core::integer::u16",
+        kind: "data"
       }
     ]
   },
@@ -4900,6 +4957,108 @@ var budokan_default = [
         name: "QualificationEntriesUpdated",
         type: "budokan::events::QualificationEntriesUpdated",
         kind: "nested"
+      },
+      {
+        name: "ProtocolFeeBpsUpdated",
+        type: "budokan::events::ProtocolFeeBpsUpdated",
+        kind: "nested"
+      },
+      {
+        name: "ProtocolFeeRecipientUpdated",
+        type: "budokan::events::ProtocolFeeRecipientUpdated",
+        kind: "nested"
+      }
+    ]
+  },
+  {
+    type: "interface",
+    name: "budokan::budokan::Budokan::IBudokanProtocolFeeAdmin",
+    items: [
+      {
+        type: "function",
+        name: "set_protocol_fee_bps",
+        inputs: [
+          {
+            name: "bps",
+            type: "core::integer::u16"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "set_protocol_fee_recipient",
+        inputs: [
+          {
+            name: "recipient",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "protocol_fee_bps",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::integer::u16"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "protocol_fee_recipient",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournament_protocol_fee_bps",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u16"
+          }
+        ],
+        state_mutability: "view"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "budokan::events::ProtocolFeeBpsUpdated",
+    kind: "struct",
+    members: [
+      {
+        name: "bps",
+        type: "core::integer::u16",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "budokan::events::ProtocolFeeRecipientUpdated",
+    kind: "struct",
+    members: [
+      {
+        name: "recipient",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
       }
     ]
   }
@@ -5367,6 +5526,185 @@ function createBudokanClient(config) {
   return new BudokanClient(config);
 }
 
+// src/utils/prizes.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonNegativeIntegerString(value) {
+  if (!isNonEmptyString(value) || value.trim() !== value) return false;
+  if (!/^\d+$/.test(value)) return false;
+  try {
+    return BigInt(value) >= 0n;
+  } catch {
+    return false;
+  }
+}
+function isNonNegativeIntegerNumber(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveIntegerNumber(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isDistributionType(value) {
+  return value === "linear" || value === "exponential" || value === "uniform" || value === "custom";
+}
+function hasNoDistributionFields(prize) {
+  return prize.distributionType === null && prize.distributionWeight === null && prize.distributionShares === null && prize.distributionCount === null;
+}
+function hasValidDistributionFields(prize) {
+  if (prize.distributionType === null) return hasNoDistributionFields(prize);
+  if (!isDistributionType(prize.distributionType)) return false;
+  if (!isPositiveIntegerNumber(prize.distributionCount)) return false;
+  if (prize.distributionType === "custom") {
+    return prize.distributionWeight === null && Array.isArray(prize.distributionShares) && prize.distributionShares.length === prize.distributionCount && prize.distributionShares.every(isNonNegativeIntegerNumber) && prize.distributionShares.reduce((sum, share) => sum + share, 0) === 1e4;
+  }
+  if (prize.distributionType === "uniform") {
+    return prize.distributionWeight === null && prize.distributionShares === null;
+  }
+  return isNonNegativeIntegerNumber(prize.distributionWeight) && prize.distributionShares === null;
+}
+function hasBasePrizeFields(prize) {
+  return isNonNegativeIntegerString(prize.prizeId) && isNonNegativeIntegerString(prize.tournamentId) && Number.isInteger(prize.payoutPosition) && prize.payoutPosition >= 0 && isNonEmptyString(prize.sponsorAddress);
+}
+function hasExtensionConfig(value) {
+  return value === null || Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function describePrize(prize) {
+  const prizeId = isNonEmptyString(prize.prizeId) ? prize.prizeId : "<invalid>";
+  return `prizeId=${prizeId}, tokenType=${prize.tokenType}`;
+}
+function malformedTokenPrizeError(action, prize) {
+  return new TypeError(
+    `Cannot ${action} malformed Budokan token prize (${describePrize(prize)})`
+  );
+}
+function malformedExtensionPrizeError(action, prize) {
+  return new TypeError(
+    `Cannot ${action} malformed Budokan extension prize (${describePrize(prize)})`
+  );
+}
+function assertMetagameTokenPosition(prize) {
+  if (Number.isInteger(prize.payoutPosition) && prize.payoutPosition > 0) {
+    return;
+  }
+  if (prize.payoutPosition !== 0) {
+    throw new TypeError(
+      `Cannot adapt Budokan token prize with invalid payout position (${describePrize(prize)})`
+    );
+  }
+  throw new TypeError(
+    `Cannot adapt Budokan token prize with unhydrated payout position (${describePrize(prize)})`
+  );
+}
+function assertMetagameExtensionPosition(prize) {
+  if (Number.isInteger(prize.payoutPosition) && prize.payoutPosition > 0) {
+    return;
+  }
+  if (prize.payoutPosition !== 0) {
+    throw new TypeError(
+      `Cannot adapt Budokan extension prize with invalid payout position (${describePrize(prize)})`
+    );
+  }
+  throw new TypeError(
+    `Cannot adapt Budokan extension prize with unhydrated payout position (${describePrize(prize)})`
+  );
+}
+function hasHydratedPayoutPosition(prize) {
+  return prize.payoutPosition > 0;
+}
+function isRawTokenPrize(prize) {
+  if (!hasBasePrizeFields(prize) || !isNonEmptyString(prize.tokenAddress)) {
+    return false;
+  }
+  return prize.tokenType === "erc20" ? isNonNegativeIntegerString(prize.amount) && prize.tokenId === null && prize.extensionAddress === null && prize.extensionConfig === null && hasValidDistributionFields(prize) : prize.tokenType === "erc721" && prize.amount === null && isNonNegativeIntegerString(prize.tokenId) && prize.extensionAddress === null && prize.extensionConfig === null && hasNoDistributionFields(prize);
+}
+function isRawExtensionPrize(prize) {
+  return hasBasePrizeFields(prize) && prize.tokenType === "extension" && prize.tokenAddress === null && prize.amount === null && prize.tokenId === null && hasNoDistributionFields(prize) && isNonEmptyString(prize.extensionAddress) && hasExtensionConfig(prize.extensionConfig);
+}
+function isTokenPrize(prize) {
+  return isRawTokenPrize(prize) && hasHydratedPayoutPosition(prize);
+}
+function isExtensionPrize(prize) {
+  return isRawExtensionPrize(prize) && hasHydratedPayoutPosition(prize);
+}
+function isMetagameAdaptablePrize(prize) {
+  return isTokenPrize(prize) || isExtensionPrize(prize);
+}
+function getRawTokenPrizes(prizes) {
+  return prizes.flatMap((prize) => {
+    if (isRawTokenPrize(prize)) return [prize];
+    if (prize.tokenType === "extension") return [];
+    throw malformedTokenPrizeError("read", prize);
+  });
+}
+function getTokenPrizes(prizes) {
+  return prizes.flatMap((prize) => {
+    if (isTokenPrize(prize)) return [prize];
+    if (isRawTokenPrize(prize) || prize.tokenType === "extension") return [];
+    throw malformedTokenPrizeError("read", prize);
+  });
+}
+function toMetagameTokenPrize(prize) {
+  assertMetagameTokenPosition(prize);
+  if (!isRawTokenPrize(prize)) {
+    throw malformedTokenPrizeError("adapt", prize);
+  }
+  const adapted = {
+    id: prize.prizeId,
+    position: prize.payoutPosition,
+    tokenAddress: prize.tokenAddress,
+    tokenType: prize.tokenType,
+    // Metagame token prizes use `amount` as the token id for ERC721 entries.
+    amount: prize.tokenType === "erc20" ? prize.amount : prize.tokenId,
+    sponsorAddress: prize.sponsorAddress
+  };
+  return adapted;
+}
+function toMetagameExtensionPrize(prize) {
+  assertMetagameExtensionPosition(prize);
+  if (!isRawExtensionPrize(prize)) {
+    throw malformedExtensionPrizeError("adapt", prize);
+  }
+  const adapted = {
+    id: prize.prizeId,
+    position: prize.payoutPosition,
+    tokenAddress: null,
+    tokenType: "extension",
+    amount: null,
+    sponsorAddress: prize.sponsorAddress,
+    extensionAddress: prize.extensionAddress,
+    extensionConfig: prize.extensionConfig
+  };
+  return adapted;
+}
+function toMetagamePrize(prize) {
+  if (isRawTokenPrize(prize)) return toMetagameTokenPrize(prize);
+  if (isRawExtensionPrize(prize)) return toMetagameExtensionPrize(prize);
+  throw new TypeError(
+    `Cannot adapt malformed Budokan prize (${describePrize(prize)})`
+  );
+}
+function tryToMetagamePrize(prize) {
+  if (!isMetagameAdaptablePrize(prize)) return null;
+  return prize.tokenType === "extension" ? toMetagameExtensionPrize(prize) : toMetagameTokenPrize(prize);
+}
+function toMetagamePrizes(prizes) {
+  return prizes.map(toMetagamePrize);
+}
+function tryToMetagamePrizes(prizes) {
+  return prizes.flatMap((prize) => {
+    const adapted = tryToMetagamePrize(prize);
+    return adapted ? [adapted] : [];
+  });
+}
+function toMetagameTokenPrizes(prizes) {
+  return prizes.flatMap((prize) => {
+    if (isRawTokenPrize(prize)) return [toMetagameTokenPrize(prize)];
+    if (prize.tokenType === "extension") return [];
+    throw malformedTokenPrizeError("adapt", prize);
+  });
+}
+
 // src/games/whitelist.ts
 var STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
 var MAINNET_GAMES_RAW = [
@@ -5753,6 +6091,9 @@ function pushRewardTypeFelts(out, reward) {
     case "entry_fee_refund":
       out.push("0x1", "0x0", "0x3", num.toHex(reward.tokenId));
       return;
+    case "entry_fee_protocol_fee":
+      out.push("0x1", "0x0", "0x4");
+      return;
     case "entry_fee_extension": {
       out.push("0x1", "0x1");
       if (reward.tokenId !== void 0) {
@@ -5794,6 +6135,248 @@ function felt252FromShortString(s) {
   }
   return "0x" + value.toString(16);
 }
+
+// src/distribution/index.ts
+var BASIS_POINTS = 10000n;
+function calculateDistribution(positions, weight, distributionType) {
+  if (positions <= 0) return [];
+  let raw;
+  if (distributionType === "uniform") {
+    raw = Array(positions).fill(1);
+  } else if (distributionType === "linear") {
+    raw = [];
+    for (let i = 0; i < positions; i++) {
+      const positionValue = positions - i;
+      raw.push(1 + (positionValue - 1) * (weight / 10));
+    }
+  } else {
+    raw = [];
+    for (let i = 0; i < positions; i++) {
+      raw.push(Math.pow(1 - i / positions, weight));
+    }
+  }
+  const total = raw.reduce((a, b) => a + b, 0);
+  if (total === 0) return Array(positions).fill(0);
+  const bpShares = raw.map((d) => Math.floor(d / total * 1e4));
+  const remaining = 1e4 - bpShares.reduce((a, b) => a + b, 0);
+  if (remaining !== 0) bpShares[0] = bpShares[0] + remaining;
+  return bpShares.map((bp) => bp / 100);
+}
+var KNOWN_KEYS = {
+  linear: "linear",
+  exponential: "exponential",
+  uniform: "uniform",
+  custom: "custom"
+};
+function parseDistribution(dist) {
+  if (!dist || typeof dist !== "object") {
+    return { type: "unknown", weight: 0 };
+  }
+  const explicit = dist;
+  if (typeof explicit.type === "string") {
+    const kind = KNOWN_KEYS[explicit.type.toLowerCase()] ?? "unknown";
+    return { type: kind, weight: Number(explicit.weight ?? 0) };
+  }
+  const bag = dist.variant ?? dist;
+  for (const [rawKey, value] of Object.entries(bag)) {
+    if (value === void 0 || value === null) continue;
+    const kind = KNOWN_KEYS[rawKey.toLowerCase()];
+    if (!kind) continue;
+    if (kind === "uniform") return { type: "uniform", weight: 0 };
+    if (kind === "custom") {
+      const arr = Array.isArray(value) ? value.map((v) => Number(v)) : [];
+      return { type: "custom", weight: 0, customWeights: arr };
+    }
+    if (typeof value === "number" || typeof value === "string" || typeof value === "bigint") {
+      return { type: kind, weight: Number(value) };
+    }
+    if (typeof value === "object" && value !== null && "Some" in value) {
+      return { type: kind, weight: Number(value.Some) };
+    }
+    return { type: kind, weight: 0 };
+  }
+  return { type: "unknown", weight: 0 };
+}
+function prizeDistribution(prize) {
+  const type = KNOWN_KEYS[String(prize.distributionType ?? "uniform").toLowerCase()] ?? "uniform";
+  if (type === "custom") {
+    return { type, weight: 0, customWeights: prize.distributionShares ?? [] };
+  }
+  return { type, weight: prize.distributionWeight ?? 10 };
+}
+function distributionPercentages(dist, count) {
+  if (count <= 0) return [];
+  if (dist.type === "custom") {
+    const cw = dist.customWeights ?? [];
+    if (cw.length === count) return cw.map((bp) => bp / 100);
+    return calculateDistribution(count, 1, "uniform");
+  }
+  const distType = dist.type === "linear" || dist.type === "exponential" || dist.type === "uniform" ? dist.type : "uniform";
+  return calculateDistribution(count, dist.weight / 10, distType);
+}
+function bps(total, share) {
+  const b = Number(share ?? 0);
+  if (b <= 0) return 0n;
+  return total * BigInt(b) / BASIS_POINTS;
+}
+function entryFeeSplit(input) {
+  const total = BigInt(input.amount ?? 0) * BigInt(input.entryCount ?? 0);
+  const creator = Number(input.tournamentCreatorShare ?? 0);
+  const game = Number(input.gameCreatorShare ?? 0);
+  const refund = Number(input.refundShare ?? 0);
+  const protocol = Number(input.protocolFeeShare ?? 0);
+  const availableShareBps = Math.max(0, 1e4 - creator - game - refund - protocol);
+  return {
+    total,
+    positionPool: total * BigInt(availableShareBps) / BASIS_POINTS,
+    tournamentCreator: bps(total, creator),
+    gameCreator: bps(total, game),
+    refund: bps(total, refund),
+    protocolFee: bps(total, protocol),
+    availableShareBps
+  };
+}
+function entryFeePositionPayout(input, position) {
+  const distCount = Number(input.distributionCount ?? 0);
+  if (distCount <= 0 || position < 1 || position > distCount) return 0n;
+  const split = entryFeeSplit(input);
+  if (split.positionPool <= 0n) return 0n;
+  const pcts = distributionPercentages(parseDistribution(input.distribution), distCount);
+  const pct = pcts[position - 1] ?? 0;
+  if (pct <= 0) return 0n;
+  return split.positionPool * BigInt(Math.floor(pct * 1e4)) / 1000000n;
+}
+function sponsorPrizePayout(prize, position) {
+  if (prize.tokenType !== "erc20") return 0n;
+  const distCount = Number(prize.distributionCount ?? 0);
+  if (distCount <= 0 || position < 1 || position > distCount) return 0n;
+  const pcts = distributionPercentages(prizeDistribution(prize), distCount);
+  const pct = pcts[position - 1] ?? 0;
+  if (pct <= 0) return 0n;
+  return BigInt(prize.amount ?? "0") * BigInt(Math.floor(pct * 1e4)) / 1000000n;
+}
+
+// src/rewards/index.ts
+function getClaimableRewards(input) {
+  const tournamentsById = /* @__PURE__ */ new Map();
+  for (const t of input.tournaments) tournamentsById.set(t.id, t);
+  const prizesByTournament = /* @__PURE__ */ new Map();
+  for (const p of input.prizes) {
+    let list = prizesByTournament.get(p.tournamentId);
+    if (!list) prizesByTournament.set(p.tournamentId, list = []);
+    list.push(p);
+  }
+  const claimedKeys = /* @__PURE__ */ new Set();
+  for (const c of input.existingClaims) {
+    if (!c.claimed) continue;
+    const key = rewardClaimKey(c);
+    if (key) claimedKeys.add(`${c.tournamentId}:${key}`);
+  }
+  const out = [];
+  for (const placement of input.placements) {
+    const tournament = tournamentsById.get(placement.tournamentId);
+    if (!tournament) continue;
+    const tournamentName = tournament.name || `#${tournament.id}`;
+    const pos = placement.position;
+    const ef = tournament.entryFee;
+    const efDistCount = Number(ef?.distributionCount ?? 0);
+    if (ef && ef.tokenAddress && efDistCount >= pos) {
+      const claimKey = `${placement.tournamentId}:EntryFee.Position.${pos}`;
+      if (!claimedKeys.has(claimKey)) {
+        const amount = entryFeePositionPayout(
+          {
+            amount: ef.amount ?? "0",
+            entryCount: tournament.entryCount ?? 0,
+            tournamentCreatorShare: ef.tournamentCreatorShare,
+            gameCreatorShare: ef.gameCreatorShare,
+            refundShare: ef.refundShare,
+            protocolFeeShare: tournament.protocolFeeShare,
+            distribution: ef.distribution,
+            distributionCount: efDistCount
+          },
+          pos
+        );
+        if (amount > 0n) {
+          out.push({
+            tournamentId: placement.tournamentId,
+            tournamentName,
+            source: "entry_fee_position",
+            position: pos,
+            tokenAddress: ef.tokenAddress,
+            tokenType: "erc20",
+            amount,
+            reward: { kind: "entry_fee_position", position: pos }
+          });
+        }
+      }
+    }
+    for (const prize of prizesByTournament.get(placement.tournamentId) ?? []) {
+      if (!isRawTokenPrize(prize)) continue;
+      const dc = prize.distributionCount ?? 0;
+      const pp = prize.payoutPosition ?? 0;
+      const isSingle = pp === pos && dc === 0;
+      const isDistributed = dc >= pos && pp === 0;
+      if (!isSingle && !isDistributed) continue;
+      const tokenType = prize.tokenType === "erc721" ? "erc721" : "erc20";
+      if (isSingle) {
+        const claimKey2 = `${placement.tournamentId}:Prize.Single.${prize.prizeId}`;
+        if (claimedKeys.has(claimKey2)) continue;
+        out.push({
+          tournamentId: placement.tournamentId,
+          tournamentName,
+          source: "sponsor_single",
+          position: pos,
+          tokenAddress: prize.tokenAddress,
+          tokenType,
+          amount: tokenType === "erc20" ? BigInt(prize.amount ?? "0") : void 0,
+          tokenId: prize.tokenId,
+          reward: { kind: "prize_single", prizeId: prize.prizeId }
+        });
+        continue;
+      }
+      const payoutIndex = pos - 1;
+      const claimKey = `${placement.tournamentId}:Prize.Distributed.${prize.prizeId}.${payoutIndex}`;
+      if (claimedKeys.has(claimKey)) continue;
+      const amount = sponsorPrizePayout(prize, pos);
+      if (amount <= 0n) continue;
+      out.push({
+        tournamentId: placement.tournamentId,
+        tournamentName,
+        source: "sponsor_distributed",
+        position: pos,
+        tokenAddress: prize.tokenAddress,
+        tokenType: "erc20",
+        amount,
+        reward: {
+          kind: "prize_distributed",
+          prizeId: prize.prizeId,
+          payoutPosition: payoutIndex
+        }
+      });
+    }
+  }
+  return out;
+}
+function buildClaimCalls(rewards, budokanAddress) {
+  return rewards.map(
+    (r) => buildClaimRewardCall(budokanAddress, {
+      tournamentId: r.tournamentId,
+      reward: r.reward
+    })
+  );
+}
+function rewardClaimKey(c) {
+  switch (c.claimKind) {
+    case "prize_single":
+      return c.prizeId ? `Prize.Single.${c.prizeId}` : null;
+    case "prize_distributed":
+      return c.prizeId != null && c.payoutIndex != null ? `Prize.Distributed.${c.prizeId}.${c.payoutIndex}` : null;
+    case "entry_fee_position":
+      return c.position != null ? `EntryFee.Position.${c.position}` : null;
+    default:
+      return null;
+  }
+}
 function sdkChainId(chain) {
   return chain === "mainnet" ? "SN_MAIN" : "SN_SEPOLIA";
 }
@@ -5862,6 +6445,6 @@ function buildTournamentValidatorConfig(cfg) {
   return [qualifierType, qualifyingMode, topPositions, ...cfg.tournamentIds];
 }
 
-export { BudokanApiError, BudokanClient, BudokanConnectionError, BudokanError, BudokanTimeoutError, CHAINS, ConnectionStatus, DataSourceError, RpcError, TournamentNotFoundError, WSManager, buildAddPrizeCall, buildClaimRewardCall, buildCreateTournamentCall, buildEnterTournamentCall, buildErc20ApproveCall, buildErc20BalanceConfig, buildMerkleConfig, buildOpusTrovesConfig, buildSubmitScoreCall, buildTournamentValidatorConfig, camelToSnake, createBudokanClient, explorerAddressUrl, explorerBaseUrl, explorerTxUrl, extensionAddressFor, findWhitelistedGame, getActivityStats, getChainConfig, getGameDefaults, getGameStats, getGameTournaments, getPrizeStats, getTournament, getTournamentPrizeAggregation, getTournamentPrizes, getTournamentQualifications, getTournamentRegistrations, getTournamentRewardClaims, getTournamentRewardClaimsSummary, getTournaments, getWhitelistedGames, isGameWhitelisted, normalizeAddress, parseTournamentIdFromReceipt, snakeToCamel, tournamentPageUrl, u256ToLowHigh, withRetry };
+export { BudokanApiError, BudokanClient, BudokanConnectionError, BudokanError, BudokanTimeoutError, CHAINS, ConnectionStatus, DataSourceError, RpcError, TournamentNotFoundError, WSManager, buildAddPrizeCall, buildClaimCalls, buildClaimRewardCall, buildCreateTournamentCall, buildEnterTournamentCall, buildErc20ApproveCall, buildErc20BalanceConfig, buildMerkleConfig, buildOpusTrovesConfig, buildSubmitScoreCall, buildTournamentValidatorConfig, camelToSnake, createBudokanClient, distributionPercentages, entryFeePositionPayout, entryFeeSplit, explorerAddressUrl, explorerBaseUrl, explorerTxUrl, extensionAddressFor, findWhitelistedGame, getActivityStats, getChainConfig, getClaimableRewards, getGameDefaults, getGameStats, getGameTournaments, getPrizeStats, getRawTokenPrizes, getTokenPrizes, getTournament, getTournamentPrizeAggregation, getTournamentPrizes, getTournamentQualifications, getTournamentRegistrations, getTournamentRewardClaims, getTournamentRewardClaimsSummary, getTournaments, getWhitelistedGames, isExtensionPrize, isGameWhitelisted, isMetagameAdaptablePrize, isRawExtensionPrize, isRawTokenPrize, isTokenPrize, normalizeAddress, parseDistribution, parseTournamentIdFromReceipt, prizeDistribution, snakeToCamel, sponsorPrizePayout, toMetagameExtensionPrize, toMetagamePrize, toMetagamePrizes, toMetagameTokenPrize, toMetagameTokenPrizes, tournamentPageUrl, tournamentPhase, tryToMetagamePrize, tryToMetagamePrizes, u256ToLowHigh, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map