@provable-games/budokan-sdk 0.1.24 → 0.1.25

package/dist/index.cjs

@@ -215,7 +215,8 @@ function camelToSnake(obj) {
 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;
+  return { ...t, id, tournamentId: id, protocolFeeShare };
 }
 function fetchOpts(ctx) {
   return {
@@ -832,7 +833,7 @@ function phaseToRpcArg(phase) {
   }
   return new starknet.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);
@@ -930,6 +931,8 @@ function parseTournament(raw, entryCount) {
     leaderboardGameMustBeOver: gameMustBeOver,
     entryFeeToken,
     entryFeeAmount,
+    // Protocol-fee bps snapshot, surfaced by the viewer's TournamentFullState.
+    protocolFeeShare,
     hasEntryRequirement,
     schedule: {
       registrationStartDelay,
@@ -1096,7 +1099,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 () => {
@@ -1272,6 +1276,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",
@@ -1744,6 +1751,10 @@ var budokanViewer_default = [
       {
         name: "phase",
         type: "budokan_interfaces::budokan::Phase"
+      },
+      {
+        name: "protocol_fee_bps",
+        type: "core::integer::u16"
       }
     ]
   },
@@ -2014,6 +2025,10 @@ var budokanViewer_default = [
       {
         name: "Refund",
         type: "core::felt252"
+      },
+      {
+        name: "ProtocolFee",
+        type: "()"
       }
     ]
   },
@@ -3392,6 +3407,10 @@ var budokan_default = [
       {
         name: "Refund",
         type: "core::felt252"
+      },
+      {
+        name: "ProtocolFee",
+        type: "()"
       }
     ]
   },
@@ -4680,6 +4699,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"
       }
     ]
   },
@@ -4902,6 +4926,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"
       }
     ]
   }
@@ -5369,6 +5495,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 = [
@@ -5755,6 +6060,9 @@ function pushRewardTypeFelts(out, reward) {
     case "entry_fee_refund":
       out.push("0x1", "0x0", "0x3", starknet.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) {
@@ -5898,6 +6206,8 @@ exports.getGameDefaults = getGameDefaults;
 exports.getGameStats = getGameStats;
 exports.getGameTournaments = getGameTournaments;
 exports.getPrizeStats = getPrizeStats;
+exports.getRawTokenPrizes = getRawTokenPrizes;
+exports.getTokenPrizes = getTokenPrizes;
 exports.getTournament = getTournament;
 exports.getTournamentPrizeAggregation = getTournamentPrizeAggregation;
 exports.getTournamentPrizes = getTournamentPrizes;
@@ -5907,11 +6217,23 @@ exports.getTournamentRewardClaims = getTournamentRewardClaims;
 exports.getTournamentRewardClaimsSummary = getTournamentRewardClaimsSummary;
 exports.getTournaments = getTournaments;
 exports.getWhitelistedGames = getWhitelistedGames;
+exports.isExtensionPrize = isExtensionPrize;
 exports.isGameWhitelisted = isGameWhitelisted;
+exports.isMetagameAdaptablePrize = isMetagameAdaptablePrize;
+exports.isRawExtensionPrize = isRawExtensionPrize;
+exports.isRawTokenPrize = isRawTokenPrize;
+exports.isTokenPrize = isTokenPrize;
 exports.normalizeAddress = normalizeAddress;
 exports.parseTournamentIdFromReceipt = parseTournamentIdFromReceipt;
 exports.snakeToCamel = snakeToCamel;
+exports.toMetagameExtensionPrize = toMetagameExtensionPrize;
+exports.toMetagamePrize = toMetagamePrize;
+exports.toMetagamePrizes = toMetagamePrizes;
+exports.toMetagameTokenPrize = toMetagameTokenPrize;
+exports.toMetagameTokenPrizes = toMetagameTokenPrizes;
 exports.tournamentPageUrl = tournamentPageUrl;
+exports.tryToMetagamePrize = tryToMetagamePrize;
+exports.tryToMetagamePrizes = tryToMetagamePrizes;
 exports.u256ToLowHigh = u256ToLowHigh;
 exports.withRetry = withRetry;
 //# sourceMappingURL=index.cjs.map