@playmos/sdk 0.3.0 → 0.3.1

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { N as Network, P as PlaymosConfig, W as WebhookEvent, R as RoundOpenInput, a as RoundState, b as RoundSettleInput, S as SettleRoundResult, A as AgentWallet, c as AgentFundResult, T as TransferResult, E as EscrowHoldInput, d as EscrowHoldResult, e as EscrowResolveResult, M as MarketplaceListInput, L as Listing, f as MarketplaceSaleResult, g as MarketplaceGetResult, h as PayInput, i as Payment, j as EnterRoundInput, k as TransferReconcile, l as WaitOptions, m as TransferInput, n as TransferConfirmOptions, V as VerifyResult } from './errors-BVESr920.cjs';
-export { o as AgentEconomyConfig, p as ApiError, q as AuthError, C as ConfigError, r as ContractConfig, s as Eip1193Provider, G as GasConfig, t as GasMode, I as InsufficientGasError, u as InvalidAmountError, v as ListingStatus, w as MarketplaceItem, x as MarketplaceSale, y as MissingFieldError, z as PaymentFailedError, B as PaymentStatus, D as PayoutRule, F as PlaymosError, H as PlaymosErrorCode, J as RetryOptions, K as RoundStatus, O as WalletConfig, Q as WalletConnectionError, U as WalletConnector, X as WebhookEventType } from './errors-BVESr920.cjs';
+import { N as Network, P as PlaymosConfig, W as WebhookEvent, R as RoundOpenInput, a as RoundState, b as RoundSettleInput, S as SettleRoundResult, c as PrizeBalance, d as WithdrawResult, A as AgentWallet, e as AgentFundResult, T as TransferResult, E as EscrowHoldInput, f as EscrowHoldResult, g as EscrowResolveResult, M as MarketplaceListInput, L as Listing, h as MarketplaceSaleResult, i as MarketplaceGetResult, j as PayInput, k as Payment, l as EnterRoundInput, m as TransferReconcile, n as WaitOptions, o as TransferInput, p as TransferConfirmOptions, V as VerifyResult } from './errors-DMtMpbR6.cjs';
+export { q as AgentEconomyConfig, r as ApiError, s as AuthError, C as ConfigError, t as ContractConfig, u as Eip1193Provider, G as GasConfig, v as GasMode, I as InsufficientGasError, w as InvalidAmountError, x as ListingStatus, y as MarketplaceItem, z as MarketplaceSale, B as MissingFieldError, D as NothingToWithdrawError, F as PaymentFailedError, H as PaymentStatus, J as PayoutRule, K as PlaymosError, O as PlaymosErrorCode, Q as RetryOptions, U as RoundStatus, X as WalletConfig, Y as WalletConnectionError, Z as WalletConnector, _ as WebhookEventType } from './errors-DMtMpbR6.cjs';
 
 /**
  * Environment resolution + the canonical address book.
@@ -80,6 +80,30 @@ declare class Playmos {
         get: (input: {
             roundId: string;
         }) => Promise<RoundState>;
+        /**
+         * Read a wallet's **claimable** prize balance for a round (issue #41).
+         * Prefers the service chain read (`GET /v1/rounds/:id/prize?wallet=`); falls
+         * back to a direct eth_call when `prizePoolAddress` is supplied and no wallet
+         * connector is needed for the read path… actually uses service first, then
+         * on-chain via the player's provider if the service is unavailable.
+         */
+        prize: (input: {
+            roundId: string;
+            wallet: `0x${string}`;
+            /** Optional override if you already hold the pool address from enterRound. */
+            prizePoolAddress?: `0x${string}`;
+        }) => Promise<PrizeBalance>;
+        /**
+         * Winner **claim** — call PrizePool.withdraw() from the player's wallet (issue #41).
+         * Pull-payment: credits from settle live in `withdrawable[msg.sender]`. No approve needed.
+         * Pass either `prizePoolAddress` (from enterRound / rounds.get) or `roundId` (service resolves).
+         */
+        withdraw: (input: {
+            prizePoolAddress?: `0x${string}`;
+            roundId?: string;
+            /** Pre-check claimable; default true. Set false only if you already called `prize()`. */
+            checkBalance?: boolean;
+        }) => Promise<WithdrawResult>;
     };
     /**
      * `agents` — assign wallets to the NPCs YOUR game already owns, so they can transact USDC in your economy.
@@ -245,6 +269,11 @@ declare class Playmos {
     /** Prefer the service's authoritative micro-USDC amount; fall back to the
      *  locally-parsed value if the service didn't echo one. */
     private resolveUnits;
+    /**
+     * Read PrizePool.withdrawable[wallet] via eth_call (issue #41).
+     * Uses the wallet provider when present; otherwise a public Base Sepolia RPC in test.
+     */
+    private readWithdrawable;
     private sponsorUrl;
     /**
      * After the batch lands, resolve the authoritative status via the service's
@@ -514,4 +543,4 @@ declare function isWalletSignatureAuthorization(auth: Authorization): auth is Wa
 /** Narrow to the declared-but-unimplemented x402 variant. */
 declare function isX402PayloadAuthorization(auth: Authorization): auth is X402PayloadAuthorization;
 
-export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, type X402PayloadAuthorization, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, ulid };
+export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, PrizeBalance, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, WithdrawResult, type X402PayloadAuthorization, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, ulid };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { N as Network, P as PlaymosConfig, W as WebhookEvent, R as RoundOpenInput, a as RoundState, b as RoundSettleInput, S as SettleRoundResult, A as AgentWallet, c as AgentFundResult, T as TransferResult, E as EscrowHoldInput, d as EscrowHoldResult, e as EscrowResolveResult, M as MarketplaceListInput, L as Listing, f as MarketplaceSaleResult, g as MarketplaceGetResult, h as PayInput, i as Payment, j as EnterRoundInput, k as TransferReconcile, l as WaitOptions, m as TransferInput, n as TransferConfirmOptions, V as VerifyResult } from './errors-BVESr920.js';
-export { o as AgentEconomyConfig, p as ApiError, q as AuthError, C as ConfigError, r as ContractConfig, s as Eip1193Provider, G as GasConfig, t as GasMode, I as InsufficientGasError, u as InvalidAmountError, v as ListingStatus, w as MarketplaceItem, x as MarketplaceSale, y as MissingFieldError, z as PaymentFailedError, B as PaymentStatus, D as PayoutRule, F as PlaymosError, H as PlaymosErrorCode, J as RetryOptions, K as RoundStatus, O as WalletConfig, Q as WalletConnectionError, U as WalletConnector, X as WebhookEventType } from './errors-BVESr920.js';
+import { N as Network, P as PlaymosConfig, W as WebhookEvent, R as RoundOpenInput, a as RoundState, b as RoundSettleInput, S as SettleRoundResult, c as PrizeBalance, d as WithdrawResult, A as AgentWallet, e as AgentFundResult, T as TransferResult, E as EscrowHoldInput, f as EscrowHoldResult, g as EscrowResolveResult, M as MarketplaceListInput, L as Listing, h as MarketplaceSaleResult, i as MarketplaceGetResult, j as PayInput, k as Payment, l as EnterRoundInput, m as TransferReconcile, n as WaitOptions, o as TransferInput, p as TransferConfirmOptions, V as VerifyResult } from './errors-DMtMpbR6.js';
+export { q as AgentEconomyConfig, r as ApiError, s as AuthError, C as ConfigError, t as ContractConfig, u as Eip1193Provider, G as GasConfig, v as GasMode, I as InsufficientGasError, w as InvalidAmountError, x as ListingStatus, y as MarketplaceItem, z as MarketplaceSale, B as MissingFieldError, D as NothingToWithdrawError, F as PaymentFailedError, H as PaymentStatus, J as PayoutRule, K as PlaymosError, O as PlaymosErrorCode, Q as RetryOptions, U as RoundStatus, X as WalletConfig, Y as WalletConnectionError, Z as WalletConnector, _ as WebhookEventType } from './errors-DMtMpbR6.js';
 
 /**
  * Environment resolution + the canonical address book.
@@ -80,6 +80,30 @@ declare class Playmos {
         get: (input: {
             roundId: string;
         }) => Promise<RoundState>;
+        /**
+         * Read a wallet's **claimable** prize balance for a round (issue #41).
+         * Prefers the service chain read (`GET /v1/rounds/:id/prize?wallet=`); falls
+         * back to a direct eth_call when `prizePoolAddress` is supplied and no wallet
+         * connector is needed for the read path… actually uses service first, then
+         * on-chain via the player's provider if the service is unavailable.
+         */
+        prize: (input: {
+            roundId: string;
+            wallet: `0x${string}`;
+            /** Optional override if you already hold the pool address from enterRound. */
+            prizePoolAddress?: `0x${string}`;
+        }) => Promise<PrizeBalance>;
+        /**
+         * Winner **claim** — call PrizePool.withdraw() from the player's wallet (issue #41).
+         * Pull-payment: credits from settle live in `withdrawable[msg.sender]`. No approve needed.
+         * Pass either `prizePoolAddress` (from enterRound / rounds.get) or `roundId` (service resolves).
+         */
+        withdraw: (input: {
+            prizePoolAddress?: `0x${string}`;
+            roundId?: string;
+            /** Pre-check claimable; default true. Set false only if you already called `prize()`. */
+            checkBalance?: boolean;
+        }) => Promise<WithdrawResult>;
     };
     /**
      * `agents` — assign wallets to the NPCs YOUR game already owns, so they can transact USDC in your economy.
@@ -245,6 +269,11 @@ declare class Playmos {
     /** Prefer the service's authoritative micro-USDC amount; fall back to the
      *  locally-parsed value if the service didn't echo one. */
     private resolveUnits;
+    /**
+     * Read PrizePool.withdrawable[wallet] via eth_call (issue #41).
+     * Uses the wallet provider when present; otherwise a public Base Sepolia RPC in test.
+     */
+    private readWithdrawable;
     private sponsorUrl;
     /**
      * After the batch lands, resolve the authoritative status via the service's
@@ -514,4 +543,4 @@ declare function isWalletSignatureAuthorization(auth: Authorization): auth is Wa
 /** Narrow to the declared-but-unimplemented x402 variant. */
 declare function isX402PayloadAuthorization(auth: Authorization): auth is X402PayloadAuthorization;
 
-export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, type X402PayloadAuthorization, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, ulid };
+export { AgentFundResult, AgentWallet, type Authorization, CHAIN_ID, type CreatePaymentRequirementInput, DEFAULT_API_BASE_URL, EnterRoundInput, EscrowHoldInput, EscrowHoldResult, EscrowResolveResult, Listing, MICRO_PER_USDC, MarketplaceGetResult, MarketplaceListInput, MarketplaceSaleResult, Network, PayInput, Payment, type PaymentRequirement, PayoutError, type PayoutRule as PayoutRuleCompute, Playmos, PlaymosConfig, PrizeBalance, RoundOpenInput, RoundSettleInput, RoundState, SettleRoundResult, type SettlementAsset, TransferConfirmOptions, TransferInput, TransferReconcile, TransferResult, USDC_ADDRESS, USDC_DECIMALS, VerifyResult, WaitOptions, type WalletSignatureAuthorization, WebhookEvent, WithdrawResult, type X402PayloadAuthorization, computeIapSplit, computePayout, computePoolSplit, createPaymentRequirement, formatMicroToUsd, isWalletSignatureAuthorization, isX402PayloadAuthorization, parsePaymentRequirement, parseUsdToMicro, prefixedId, previewEscrowFee, previewIapSplit, previewMarketplaceSplit, previewPoolSplit, previewTransferSplit, serializePaymentRequirement, ulid };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { InvalidAmountError, ConfigError, ApiError, MissingFieldError, AuthError, WalletConnectionError, InsufficientGasError, PaymentFailedError } from './chunk-B7SHFZYY.js';
-export { ApiError, AuthError, ConfigError, InsufficientGasError, InvalidAmountError, MissingFieldError, PaymentFailedError, PlaymosError, WalletConnectionError } from './chunk-B7SHFZYY.js';
-import { encodeFunctionData, numberToHex, keccak256, toBytes } from 'viem';
+import { InvalidAmountError, ConfigError, NothingToWithdrawError, PaymentFailedError, ApiError, MissingFieldError, WalletConnectionError, InsufficientGasError, AuthError } from './chunk-TMBBEGIF.js';
+export { ApiError, AuthError, ConfigError, InsufficientGasError, InvalidAmountError, MissingFieldError, NothingToWithdrawError, PaymentFailedError, PlaymosError, WalletConnectionError } from './chunk-TMBBEGIF.js';
+import { encodeFunctionData, decodeFunctionResult, numberToHex, keccak256, toBytes } from 'viem';
 
 // src/config.ts
 var CHAIN_ID = {
@@ -403,6 +403,13 @@ var prizePoolAbi = [
     ],
     outputs: [{ type: "bool" }]
   },
+  {
+    type: "function",
+    name: "withdrawable",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }]
+  },
   {
     type: "function",
     name: "withdraw",
@@ -490,6 +497,14 @@ function buildEntryCalls(args) {
     { to: args.prizePool, data: enterData }
   ];
 }
+function buildWithdrawCall(prizePool) {
+  const data = encodeFunctionData({
+    abi: prizePoolAbi,
+    functionName: "withdraw",
+    args: []
+  });
+  return { to: prizePool, data };
+}
 
 // src/mock.ts
 var MOCK_TX = "0x000000000000000000000000000000000000000000000000000000000000mock";
@@ -534,6 +549,9 @@ function mockEntryPayment(args) {
     },
     gameId: args.gameId,
     roundId: args.roundId,
+    roundKey: args.roundId,
+    // Deterministic mock pool address so claim-flow unit tests can assert shape (#41).
+    prizePoolAddress: "0x0000000000000000000000000000000000000001",
     playerId: args.playerId,
     txHash: MOCK_TX,
     chain: args.chain,
@@ -646,6 +664,112 @@ var Playmos = class {
           `/rounds/${encodeURIComponent(input.roundId)}`
         );
         return round;
+      },
+      /**
+       * Read a wallet's **claimable** prize balance for a round (issue #41).
+       * Prefers the service chain read (`GET /v1/rounds/:id/prize?wallet=`); falls
+       * back to a direct eth_call when `prizePoolAddress` is supplied and no wallet
+       * connector is needed for the read path… actually uses service first, then
+       * on-chain via the player's provider if the service is unavailable.
+       */
+      prize: async (input) => {
+        requireField(input?.roundId, "roundId");
+        const wallet = requireAddressField(input?.wallet, "wallet");
+        try {
+          const res = await this.http.get(
+            `/rounds/${encodeURIComponent(input.roundId)}/prize?wallet=${encodeURIComponent(wallet)}`
+          );
+          return res.prize;
+        } catch (e) {
+          if (!input.prizePoolAddress && !(e instanceof ApiError)) throw e;
+          if (!input.prizePoolAddress) throw e;
+        }
+        const prizePoolAddress = requireAddressField(input.prizePoolAddress, "prizePoolAddress");
+        const claimableMicro = await this.readWithdrawable(prizePoolAddress, wallet);
+        return {
+          roundId: input.roundId,
+          prizePoolAddress,
+          wallet,
+          claimable: formatMicroToUsd(claimableMicro),
+          claimableMicro: claimableMicro.toString()
+        };
+      },
+      /**
+       * Winner **claim** — call PrizePool.withdraw() from the player's wallet (issue #41).
+       * Pull-payment: credits from settle live in `withdrawable[msg.sender]`. No approve needed.
+       * Pass either `prizePoolAddress` (from enterRound / rounds.get) or `roundId` (service resolves).
+       */
+      withdraw: async (input) => {
+        if (this.config.mock) {
+          return {
+            prizePoolAddress: input.prizePoolAddress ?? "0x0000000000000000000000000000000000000001",
+            amount: "0.00",
+            amountMicro: "0",
+            txHash: "0x000000000000000000000000000000000000000000000000000000000000mock",
+            status: "confirmed"
+          };
+        }
+        let prizePool = input.prizePoolAddress ? requireAddressField(input.prizePoolAddress, "prizePoolAddress") : void 0;
+        if (!prizePool) {
+          requireField(input?.roundId, "roundId");
+          const round = await this.rounds.get({ roundId: input.roundId });
+          if (!round.prizePoolAddress) {
+            throw new ConfigError(
+              "rounds.get did not return prizePoolAddress \u2014 pass prizePoolAddress from enterRound or configure contracts.prizePool"
+            );
+          }
+          prizePool = round.prizePoolAddress;
+        }
+        const provider = resolveProvider(this.config.wallet);
+        if (this.config.gas?.mode === "player") {
+          const from0 = await getAccount(provider);
+          await assertEnoughGas(provider, from0);
+        }
+        const from = await getAccount(provider);
+        let amountMicro = 0n;
+        if (input.checkBalance !== false) {
+          amountMicro = await this.readWithdrawable(prizePool, from);
+          if (amountMicro === 0n) {
+            throw new NothingToWithdrawError({ prizePoolAddress: prizePool, wallet: from });
+          }
+        }
+        const call = buildWithdrawCall(prizePool);
+        const paymasterUrl = this.config.gas?.mode === "sponsored" ? this.config.gas.paymasterUrl : void 0;
+        let txHash;
+        let status = "pending";
+        try {
+          const { id: callsId } = await sendCalls(
+            provider,
+            from,
+            this.env.chainId,
+            [call],
+            paymasterUrl
+          );
+          const waited = await waitForCalls(provider, callsId);
+          txHash = waited.txHash;
+          status = waited.status === "CONFIRMED" ? "confirmed" : waited.status === "FAILED" ? "failed" : "pending";
+        } catch (e) {
+          const msg = e?.message ?? String(e);
+          if (/NothingToWithdraw|nothing to withdraw/i.test(msg)) {
+            throw new NothingToWithdrawError({ prizePoolAddress: prizePool, wallet: from, cause: msg });
+          }
+          if (e instanceof NothingToWithdrawError || e instanceof PaymentFailedError) throw e;
+          throw new PaymentFailedError("PrizePool.withdraw() failed.", { cause: msg });
+        }
+        if (status === "failed") {
+          throw new PaymentFailedError("PrizePool.withdraw() did not confirm on-chain.", {
+            prizePoolAddress: prizePool,
+            txHash
+          });
+        }
+        if (amountMicro === 0n && input.checkBalance === false) ;
+        return {
+          prizePoolAddress: prizePool,
+          amount: formatMicroToUsd(amountMicro),
+          amountMicro: amountMicro.toString(),
+          txHash,
+          status
+        };
       }
     };
     /**
@@ -975,6 +1099,9 @@ var Playmos = class {
       );
       const payment2 = this.mapServerPayment(res.payment, "entry", amountMicro);
       if (input.identity) payment2.identity = input.identity;
+      const pool = res.clientParams?.contractAddress ?? this.config.contracts?.prizePool;
+      if (pool) payment2.prizePoolAddress = pool.toLowerCase();
+      payment2.roundKey = res.clientParams?.roundKey ?? res.clientParams?.roundId ?? payment2.roundId ?? input.roundId;
       return payment2;
     }
     const intent = await this.http.post(
@@ -1002,6 +1129,8 @@ var Playmos = class {
     const { txHash } = await waitForCalls(provider, callsId);
     const payment = await this.settle(intent.payment.id, txHash);
     payment.identity = identity;
+    payment.prizePoolAddress = prizePool.toLowerCase();
+    payment.roundKey = roundKey;
     return payment;
   }
   /**
@@ -1111,6 +1240,58 @@ var Playmos = class {
     const fromServer = intent.clientParams?.amountUnits ?? intent.clientParams?.amountMicro;
     return fromServer ? BigInt(fromServer) : local;
   }
+  /**
+   * Read PrizePool.withdrawable[wallet] via eth_call (issue #41).
+   * Uses the wallet provider when present; otherwise a public Base Sepolia RPC in test.
+   */
+  async readWithdrawable(prizePool, wallet) {
+    const data = encodeFunctionData({
+      abi: prizePoolAbi,
+      functionName: "withdrawable",
+      args: [wallet]
+    });
+    let raw;
+    try {
+      if (await walletAvailable(this.config.wallet)) {
+        const provider = resolveProvider(this.config.wallet);
+        raw = await provider.request({
+          method: "eth_call",
+          params: [{ to: prizePool, data }, "latest"]
+        });
+      } else {
+        const rpc = this.env.network === "base" ? "https://mainnet.base.org" : "https://sepolia.base.org";
+        const res = await fetch(rpc, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "eth_call",
+            params: [{ to: prizePool, data }, "latest"]
+          })
+        });
+        const json = await res.json();
+        if (!json.result) {
+          throw new ApiError(
+            `eth_call withdrawable failed: ${json.error?.message ?? "no result"}`,
+            { prizePool, wallet }
+          );
+        }
+        raw = json.result;
+      }
+    } catch (e) {
+      if (e instanceof ApiError) throw e;
+      throw new ApiError(`Could not read withdrawable balance: ${e.message}`, {
+        prizePool,
+        wallet
+      });
+    }
+    return decodeFunctionResult({
+      abi: prizePoolAbi,
+      functionName: "withdrawable",
+      data: raw
+    });
+  }
   sponsorUrl(intent) {
     if (this.config.gas?.mode === "player") return void 0;
     return this.config.gas?.paymasterUrl ?? intent.clientParams?.paymasterUrl;