@provable-games/budokan-sdk 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -213,12 +213,8 @@ function camelToSnake(obj) {
 // src/api/tournaments.ts
 function normalizeTournament(raw) {
   const t = snakeToCamel(raw);
-  if (t.id && !t.tournamentId) {
-    t.tournamentId = t.id;
-  } else if (t.tournamentId && !t.id) {
-    t.id = t.tournamentId;
-  }
-  return t;
+  const id = t.id ?? t.tournamentId;
+  return { ...t, id, tournamentId: id };
 }
 function fetchOpts(ctx) {
   return {
@@ -351,11 +347,12 @@ async function getPlayerTournaments(baseUrl, address, params, ctx) {
     game_token_ids: params?.gameTokenIds?.join(",")
   });
   const result = await apiFetch(`${baseUrl}/players/${normalized}/tournaments${qs}`, fetchOpts2(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
   return {
     data: result.data.map((item) => snakeToCamel(item)),
-    total: result.pagination?.total ?? result.total,
-    limit: result.pagination?.limit ?? result.limit,
-    offset: result.pagination?.offset ?? result.offset
+    total,
+    limit: resLimit,
+    offset: resOffset
   };
 }
 async function getPlayerStats(baseUrl, address, ctx) {
@@ -384,11 +381,12 @@ async function getGameTournaments(baseUrl, gameAddress, params, ctx) {
     offset: params?.offset
   });
   const result = await apiFetch(`${baseUrl}/games/${normalized}/tournaments${qs}`, fetchOpts3(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
   return {
     data: result.data.map((item) => snakeToCamel(item)),
-    total: result.pagination?.total ?? result.total,
-    limit: result.pagination?.limit ?? result.limit,
-    offset: result.pagination?.offset ?? result.offset
+    total,
+    limit: resLimit,
+    offset: resOffset
   };
 }
 async function getGameStats(baseUrl, gameAddress, ctx) {
@@ -417,11 +415,12 @@ async function getActivity(baseUrl, params, ctx) {
     offset: params?.offset
   });
   const result = await apiFetch(`${baseUrl}/activity${qs}`, fetchOpts4(ctx));
+  const { total, limit: resLimit, offset: resOffset } = extractPagination(result, { limit: params?.limit, offset: params?.offset });
   return {
     data: result.data.map((item) => snakeToCamel(item)),
-    total: result.pagination?.total ?? result.total,
-    limit: result.pagination?.limit ?? result.limit,
-    offset: result.pagination?.offset ?? result.offset
+    total,
+    limit: resLimit,
+    offset: resOffset
   };
 }
 async function getActivityStats(baseUrl, ctx) {
@@ -597,19 +596,15 @@ var CHAINS = {
     rpcUrl: "https://api.cartridge.gg/x/starknet/mainnet/rpc/v0_10",
     apiBaseUrl: "https://budokan-api-production.up.railway.app",
     wsUrl: "wss://budokan-api-production.up.railway.app/ws",
-    budokanAddress: "",
-    // TODO: set after mainnet deployment
-    viewerAddress: ""
-    // TODO: set after mainnet deployment
+    budokanAddress: "0x06137ee50f57d08e1d0d758045e45982e2f5ef4826091ed4db136e7afbafecce",
+    viewerAddress: "0x075d1b9f1a9751e6b8f8b5a4ca8e721f10c58d87607e703cda062e512a434443"
   },
   sepolia: {
     rpcUrl: "https://starknet-sepolia.public.blastapi.io",
     apiBaseUrl: "https://budokan-api-sepolia.up.railway.app",
     wsUrl: "wss://budokan-api-sepolia.up.railway.app/ws",
-    budokanAddress: "",
-    // TODO: set after sepolia deployment
-    viewerAddress: ""
-    // TODO: set after sepolia deployment
+    budokanAddress: "0x0072a26c29ba5021508bbbb8487663a2a536b8a926acf388d3d772961bd063e0",
+    viewerAddress: "0x06bef644110a02c1b075b539953c707cd03b4bb32b42f5f1b0b0090b5139529f"
   }
 };
 function getChainConfig(chain) {
@@ -789,7 +784,6 @@ async function withFallback(primary, fallback, health) {
 
 // src/rpc/provider.ts
 var starknetModule = null;
-var useObjectConstructor = null;
 async function getStarknet() {
   if (!starknetModule) {
     starknetModule = await import('starknet');
@@ -807,30 +801,7 @@ async function createContract(abi, address, provider) {
     resolvedAbi = abi.default;
   }
   const starknet = await getStarknet();
-  const StarknetContract = starknet.Contract;
-  if (useObjectConstructor === null) {
-    try {
-      const contract = new StarknetContract({
-        abi: resolvedAbi,
-        address,
-        providerOrAccount: provider
-      });
-      useObjectConstructor = true;
-      return contract;
-    } catch {
-      useObjectConstructor = false;
-      return new StarknetContract(resolvedAbi, address, provider);
-    }
-  }
-  if (useObjectConstructor) {
-    return new StarknetContract({
-      abi: resolvedAbi,
-      address,
-      providerOrAccount: provider
-    });
-  } else {
-    return new StarknetContract(resolvedAbi, address, provider);
-  }
+  return new starknet.Contract({ abi: resolvedAbi, address, providerOrAccount: provider });
 }
 function wrapRpcCall(fn, contractAddress) {
   return fn().catch((error) => {
@@ -878,16 +849,22 @@ function decodeByteArray(value) {
   }
   return result;
 }
+var PHASE_VARIANTS = ["Scheduled", "Registration", "Staging", "Live", "Submission", "Finalized"];
+var PHASE_NAME_MAP = {
+  scheduled: "Scheduled",
+  registration: "Registration",
+  staging: "Staging",
+  live: "Live",
+  submission: "Submission",
+  finalized: "Finalized"
+};
 function phaseToRpcArg(phase) {
-  const map = {
-    scheduled: "Scheduled",
-    registration: "Registration",
-    staging: "Staging",
-    live: "Live",
-    submission: "Submission",
-    finalized: "Finalized"
-  };
-  return { [map[phase]]: {} };
+  const activeVariant = PHASE_NAME_MAP[phase];
+  const variants = {};
+  for (const v of PHASE_VARIANTS) {
+    variants[v] = v === activeVariant ? {} : void 0;
+  }
+  return new starknet.CairoCustomEnum(variants);
 }
 function parseTournament(raw, entryCount) {
   const obj = raw;
@@ -905,11 +882,16 @@ function parseTournament(raw, entryCount) {
   const gameEndDelay = Number(sched?.game_end_delay ?? 0);
   const submissionDuration = Number(sched?.submission_duration ?? 0);
   const createdAtStr = String(createdAt);
-  const registrationStartTime = String(createdAt + registrationStartDelay);
-  const registrationEndTime = String(createdAt + registrationEndDelay);
-  const gameStartTime = String(createdAt + gameStartDelay);
-  const gameEndTime = String(createdAt + gameEndDelay);
-  const submissionEndTime = String(createdAt + gameEndDelay + submissionDuration);
+  const regStart = createdAt + registrationStartDelay;
+  const regEnd = regStart + registrationEndDelay;
+  const gameStart = createdAt + gameStartDelay;
+  const gameEnd = gameStart + gameEndDelay;
+  const subEnd = gameEnd + submissionDuration;
+  const registrationStartTime = String(regStart);
+  const registrationEndTime = String(regEnd);
+  const gameStartTime = String(gameStart);
+  const gameEndTime = String(gameEnd);
+  const submissionEndTime = String(subEnd);
   const gc = obj.game_config;
   const gameAddress = gc ? starknet.num.toHex(gc.game_address) : "";
   const settingsId = Number(gc?.settings_id ?? 0);
@@ -938,7 +920,7 @@ function parseTournament(raw, entryCount) {
       distributionCount: Number(ef.distribution_count ?? 0)
     };
   }
-  const entryRequirement = parseOption(obj.entry_requirement) ?? null;
+  const entryRequirement = parseOption(obj.entry_requirement);
   const hasEntryRequirement = entryRequirement !== null;
   return {
     id,
@@ -1028,35 +1010,30 @@ function parsePrize(raw) {
   let distributionCount = null;
   let payoutPosition = 0;
   if (tokenTypeData) {
-    if ("erc20" in tokenTypeData) {
-      const erc20 = tokenTypeData.erc20;
+    const activeVariant = typeof tokenTypeData.activeVariant === "function" ? tokenTypeData.activeVariant() : tokenTypeData.erc20 !== void 0 ? "erc20" : tokenTypeData.erc721 !== void 0 ? "erc721" : null;
+    const variantData = tokenTypeData.variant;
+    const unwrap = (name) => variantData?.[name] ?? tokenTypeData[name];
+    if (activeVariant === "erc20") {
+      const erc20 = unwrap("erc20");
       tokenType = "erc20";
-      amount = String(erc20.amount ?? "0");
-      const dist = erc20.distribution;
-      if (dist) {
-        distributionType = String(dist.type ?? null);
-        distributionWeight = dist.weight != null ? Number(dist.weight) : null;
-      }
-      distributionCount = erc20.distribution_count != null ? Number(erc20.distribution_count) : null;
-    } else if ("erc721" in tokenTypeData) {
-      const erc721 = tokenTypeData.erc721;
-      tokenType = "erc721";
-      tokenId = String(erc721.id ?? "0");
-    } else if ("variant" in tokenTypeData) {
-      const variant = tokenTypeData.variant?.toLowerCase();
-      if (variant === "erc20") {
-        tokenType = "erc20";
-        amount = String(tokenTypeData.amount ?? "0");
-        const dist = tokenTypeData.distribution;
-        if (dist) {
-          distributionType = String(dist.type ?? null);
-          distributionWeight = dist.weight != null ? Number(dist.weight) : null;
+      amount = String(erc20?.amount ?? "0");
+      const distOption = erc20?.distribution;
+      const distInner = distOption?.Some;
+      if (distInner) {
+        const distVariant = distInner.variant ?? distInner;
+        const distType = Object.keys(distVariant).find((k) => distVariant[k] !== void 0);
+        if (distType) {
+          distributionType = distType.toLowerCase();
+          const distValue = distVariant[distType];
+          distributionWeight = distValue != null ? Number(distValue) : null;
         }
-        distributionCount = tokenTypeData.distribution_count != null ? Number(tokenTypeData.distribution_count) : null;
-      } else if (variant === "erc721") {
-        tokenType = "erc721";
-        tokenId = String(tokenTypeData.id ?? "0");
       }
+      const countOption = erc20?.distribution_count;
+      distributionCount = countOption?.Some != null ? Number(countOption.Some) : null;
+    } else if (activeVariant === "erc721") {
+      const erc721 = unwrap("erc721");
+      tokenType = "erc721";
+      tokenId = String(erc721?.id ?? "0");
     }
   }
   return {
@@ -1120,9 +1097,24 @@ async function viewerTournamentsByCreator(contract, creator, offset, limit) {
     return parseFilterResult(result);
   }, contract.address);
 }
+var PHASE_GROUPS = {
+  scheduled: ["scheduled", "registration", "staging"],
+  registration: ["registration"],
+  staging: ["staging"],
+  live: ["live", "submission"],
+  submission: ["submission"],
+  finalized: ["finalized"]
+};
 async function viewerTournamentsByPhase(contract, phase, offset, limit) {
+  const phases = PHASE_GROUPS[phase];
+  if (phases.length === 1) {
+    return wrapRpcCall(async () => {
+      const result = await contract.call("tournaments_by_phase", [phaseToRpcArg(phase), offset, limit]);
+      return parseFilterResult(result);
+    }, contract.address);
+  }
   return wrapRpcCall(async () => {
-    const result = await contract.call("tournaments_by_phase", [phaseToRpcArg(phase), offset, limit]);
+    const result = await contract.call("tournaments_by_phases", [phases.map(phaseToRpcArg), offset, limit]);
     return parseFilterResult(result);
   }, contract.address);
 }
@@ -1164,6 +1156,31 @@ async function viewerPrizes(contract, tournamentId) {
     return result.map(parsePrize);
   }, contract.address);
 }
+async function viewerRewardClaims(contract, tournamentId, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("tournament_reward_claims", [tournamentId, offset, limit]);
+    const obj = result;
+    const claims = obj.claims?.map((raw) => {
+      const claim = raw;
+      return {
+        rewardType: claim.reward_type,
+        claimed: Boolean(claim.claimed)
+      };
+    }) ?? [];
+    return {
+      claims,
+      total: Number(obj.total ?? 0),
+      totalClaimed: Number(obj.total_claimed ?? 0),
+      totalUnclaimed: Number(obj.total_unclaimed ?? 0)
+    };
+  }, contract.address);
+}
+async function viewerPlayerTournaments(contract, playerAddress, offset, limit) {
+  return wrapRpcCall(async () => {
+    const result = await contract.call("player_tournaments", [playerAddress, offset, limit]);
+    return parseFilterResult(result);
+  }, contract.address);
+}
 
 // src/rpc/abis/budokanViewer.json
 var budokanViewer_default = [
@@ -1449,16 +1466,6 @@ var budokanViewer_default = [
       }
     ]
   },
-  {
-    type: "struct",
-    name: "core::array::Span::<core::starknet::contract_address::ContractAddress>",
-    members: [
-      {
-        name: "snapshot",
-        type: "@core::array::Array::<core::starknet::contract_address::ContractAddress>"
-      }
-    ]
-  },
   {
     type: "struct",
     name: "core::array::Span::<core::felt252>",
@@ -1471,7 +1478,7 @@ var budokanViewer_default = [
   },
   {
     type: "struct",
-    name: "interfaces::extension::ExtensionConfig",
+    name: "metagame_extensions_interfaces::extension::ExtensionConfig",
     members: [
       {
         name: "address",
@@ -1491,13 +1498,9 @@ var budokanViewer_default = [
         name: "token",
         type: "core::starknet::contract_address::ContractAddress"
       },
-      {
-        name: "allowlist",
-        type: "core::array::Span::<core::starknet::contract_address::ContractAddress>"
-      },
       {
         name: "extension",
-        type: "interfaces::extension::ExtensionConfig"
+        type: "metagame_extensions_interfaces::extension::ExtensionConfig"
       }
     ]
   },
@@ -1757,6 +1760,92 @@ var budokanViewer_default = [
       }
     ]
   },
+  {
+    type: "enum",
+    name: "game_components_interfaces::prize::PrizeType",
+    variants: [
+      {
+        name: "Single",
+        type: "core::integer::u64"
+      },
+      {
+        name: "Distributed",
+        type: "(core::integer::u64, core::integer::u32)"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "budokan_interfaces::budokan::EntryFeeRewardType",
+    variants: [
+      {
+        name: "Position",
+        type: "core::integer::u32"
+      },
+      {
+        name: "TournamentCreator",
+        type: "()"
+      },
+      {
+        name: "GameCreator",
+        type: "()"
+      },
+      {
+        name: "Refund",
+        type: "core::felt252"
+      }
+    ]
+  },
+  {
+    type: "enum",
+    name: "budokan_interfaces::budokan::RewardType",
+    variants: [
+      {
+        name: "Prize",
+        type: "game_components_interfaces::prize::PrizeType"
+      },
+      {
+        name: "EntryFee",
+        type: "budokan_interfaces::budokan::EntryFeeRewardType"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::RewardClaimView",
+    members: [
+      {
+        name: "reward_type",
+        type: "budokan_interfaces::budokan::RewardType"
+      },
+      {
+        name: "claimed",
+        type: "core::bool"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "budokan_interfaces::viewer::RewardClaimResult",
+    members: [
+      {
+        name: "claims",
+        type: "core::array::Array::<budokan_interfaces::viewer::RewardClaimView>"
+      },
+      {
+        name: "total",
+        type: "core::integer::u32"
+      },
+      {
+        name: "total_claimed",
+        type: "core::integer::u32"
+      },
+      {
+        name: "total_unclaimed",
+        type: "core::integer::u32"
+      }
+    ]
+  },
   {
     type: "interface",
     name: "budokan_interfaces::viewer::IBudokanViewer",
@@ -1853,6 +1942,30 @@ var budokanViewer_default = [
         ],
         state_mutability: "view"
       },
+      {
+        type: "function",
+        name: "tournaments_by_phases",
+        inputs: [
+          {
+            name: "phases",
+            type: "core::array::Array::<budokan_interfaces::budokan::Phase>"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
+      },
       {
         type: "function",
         name: "count_tournaments",
@@ -1912,6 +2025,22 @@ var budokanViewer_default = [
         ],
         state_mutability: "view"
       },
+      {
+        type: "function",
+        name: "count_tournaments_by_phases",
+        inputs: [
+          {
+            name: "phases",
+            type: "core::array::Array::<budokan_interfaces::budokan::Phase>"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u64"
+          }
+        ],
+        state_mutability: "view"
+      },
       {
         type: "function",
         name: "tournament_detail",
@@ -2007,6 +2136,54 @@ var budokanViewer_default = [
           }
         ],
         state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "tournament_reward_claims",
+        inputs: [
+          {
+            name: "tournament_id",
+            type: "core::integer::u64"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u32"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u32"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::RewardClaimResult"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "player_tournaments",
+        inputs: [
+          {
+            name: "player_address",
+            type: "core::starknet::contract_address::ContractAddress"
+          },
+          {
+            name: "offset",
+            type: "core::integer::u64"
+          },
+          {
+            name: "limit",
+            type: "core::integer::u64"
+          }
+        ],
+        outputs: [
+          {
+            type: "budokan_interfaces::viewer::TournamentFilterResult"
+          }
+        ],
+        state_mutability: "view"
       }
     ]
   },
@@ -2291,6 +2468,41 @@ var BudokanClient = class {
       let data = [];
       if (filterResult.tournamentIds.length > 0) {
         data = await viewerTournamentsBatch(contract, filterResult.tournamentIds);
+        if (params?.includePrizeSummary) {
+          const prizePromises = data.map(
+            (t) => viewerPrizes(contract, t.id).catch(() => [])
+          );
+          const allPrizes = await Promise.all(prizePromises);
+          data = data.map((t, i) => {
+            const prizes = allPrizes[i];
+            if (prizes.length === 0) return t;
+            const tokenMap = /* @__PURE__ */ new Map();
+            for (const p of prizes) {
+              const key = p.tokenAddress;
+              const existing = tokenMap.get(key);
+              if (existing) {
+                existing.totalAmount += BigInt(p.amount ?? "0");
+                if (p.tokenType === "erc721") existing.nftCount += 1;
+              } else {
+                tokenMap.set(key, {
+                  tokenAddress: p.tokenAddress,
+                  tokenType: p.tokenType,
+                  totalAmount: BigInt(p.amount ?? "0"),
+                  nftCount: p.tokenType === "erc721" ? 1 : 0
+                });
+              }
+            }
+            return {
+              ...t,
+              prizeAggregation: Array.from(tokenMap.values()).map((v) => ({
+                tokenAddress: v.tokenAddress,
+                tokenType: v.tokenType,
+                totalAmount: v.totalAmount.toString(),
+                nftCount: v.nftCount
+              }))
+            };
+          });
+        }
       }
       return { data, total: filterResult.total, limit, offset };
     };
@@ -2381,10 +2593,32 @@ var BudokanClient = class {
   // ---- Player Queries (API-only, no on-chain equivalent) ----
   /**
    * Fetch tournaments that a player has registered for.
-   * API-only — no RPC fallback available.
+   * Supports RPC fallback via viewer contract.
    */
   async getPlayerTournaments(address, params) {
-    return getPlayerTournaments(this.resolvedConfig.apiBaseUrl, address, params, this.apiCtx);
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 20;
+      const filterResult = await viewerPlayerTournaments(contract, address, offset, limit);
+      let data = [];
+      if (filterResult.tournamentIds.length > 0) {
+        const tournaments = await viewerTournamentsBatch(contract, filterResult.tournamentIds);
+        data = tournaments.map((t) => ({
+          ...t,
+          tournamentId: t.id
+        }));
+      }
+      return { data, total: filterResult.total, limit, offset };
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getPlayerTournaments(this.resolvedConfig.apiBaseUrl, address, params, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
   }
   /**
    * Fetch stats for a player.
@@ -2426,20 +2660,55 @@ var BudokanClient = class {
   async getGameStats(gameAddress) {
     return getGameStats(this.resolvedConfig.apiBaseUrl, gameAddress, this.apiCtx);
   }
-  // ---- Reward Claims & Qualifications (API-only) ----
+  // ---- Reward Claims & Qualifications ----
   /**
    * Fetch reward claims for a tournament.
-   * API-only -- no RPC fallback available.
+   * Supports RPC fallback via viewer contract.
    */
   async getTournamentRewardClaims(tournamentId, params) {
-    return getTournamentRewardClaims(this.resolvedConfig.apiBaseUrl, tournamentId, params, this.apiCtx);
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const offset = params?.offset ?? 0;
+      const limit = params?.limit ?? 100;
+      const result = await viewerRewardClaims(contract, tournamentId, offset, limit);
+      const data = result.claims.map((c) => ({
+        tournamentId,
+        rewardType: c.rewardType,
+        claimed: c.claimed
+      }));
+      return { data, total: result.total, limit, offset };
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournamentRewardClaims(this.resolvedConfig.apiBaseUrl, tournamentId, params, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
   }
   /**
    * Fetch reward claims summary for a tournament.
-   * API-only -- no RPC fallback available.
+   * Supports RPC fallback via viewer contract.
    */
   async getTournamentRewardClaimsSummary(tournamentId) {
-    return getTournamentRewardClaimsSummary(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx);
+    const rpcFallback = async () => {
+      const contract = await this.getViewerContract();
+      const result = await viewerRewardClaims(contract, tournamentId, 0, 0);
+      return {
+        totalPrizes: result.total,
+        totalClaimed: result.totalClaimed,
+        totalUnclaimed: result.totalUnclaimed
+      };
+    };
+    if (this.resolvedConfig.primarySource === "rpc") {
+      return rpcFallback();
+    }
+    return withFallback(
+      () => getTournamentRewardClaimsSummary(this.resolvedConfig.apiBaseUrl, tournamentId, this.apiCtx),
+      rpcFallback,
+      this.connectionStatus
+    );
   }
   /**
    * Fetch qualifications for a tournament.