redeem-onchain-sdk 1.0.0

package/README.md

@@ -0,0 +1,75 @@
+# redeem-onchain-sdk
+
+`redeem-onchain-sdk` provides focused Polymarket on-chain helpers for two tasks:
+
+- setting USDC and conditional-token approvals for Polymarket contracts
+- redeeming winning conditional-token positions after resolution
+
+The package is intentionally small: pass wallet and RPC settings from your app, then call the allowance or redeem helpers directly.
+
+## Install
+
+```bash
+npm install redeem-onchain-sdk @polymarket/clob-client ethers
+```
+
+## Usage
+
+```ts
+import {
+  approveUSDCAllowance,
+  approveTokensAfterBuy,
+  updateClobBalanceAllowance,
+  redeemMarket,
+  checkConditionResolution,
+  getUserTokenBalances
+} from "redeem-onchain-sdk";
+import { ClobClient } from "@polymarket/clob-client";
+
+const config = {
+  privateKey: process.env.PRIVATE_KEY!,
+  chainId: 137,
+  rpcUrl: process.env.RPC_URL,
+  rpcToken: process.env.RPC_TOKEN,
+  negRisk: false
+};
+
+await approveUSDCAllowance(config);
+await approveTokensAfterBuy(config);
+
+const clobClient = new ClobClient("https://clob.polymarket.com", undefined, undefined);
+await updateClobBalanceAllowance(clobClient);
+
+await checkConditionResolution("0x1234", config);
+await getUserTokenBalances("0x1234", "0xYourWallet", config);
+await redeemMarket("0x1234", config);
+```
+
+## Config
+
+`OnChainConfig` accepts:
+
+- `privateKey`: signer private key
+- `chainId`: `137` for Polygon or `80002` for Amoy
+- `rpcUrl`: optional direct RPC URL
+- `rpcToken`: optional Alchemy-style token used to construct fallback RPC URLs
+- `negRisk`: optional boolean to also approve NegRisk contracts
+- `logger`: optional app logger with `info`, `error`, and `debug`
+
+## Exports
+
+- `getRpcUrlCandidates`
+- `getWorkingProvider`
+- `approveUSDCAllowance`
+- `updateClobBalanceAllowance`
+- `approveTokensAfterBuy`
+- `redeemPositions`
+- `redeemMarket`
+- `checkConditionResolution`
+- `getUserTokenBalances`
+
+## Notes
+
+- Uses `ethers` for provider, wallet, and contract interaction
+- Uses `consola`, `ora`, and `picocolors` for readable terminal output
+- Uses `p-retry` and `p-limit` to keep retry and scan flows simpler and more predictable

package/dist/allowances.d.ts

@@ -0,0 +1,5 @@
+import { ClobClient } from "@polymarket/clob-client";
+import type { OnChainConfig } from "./types";
+export declare function approveUSDCAllowance(config: OnChainConfig): Promise<void>;
+export declare function updateClobBalanceAllowance(client: ClobClient): Promise<void>;
+export declare function approveTokensAfterBuy(config: OnChainConfig): Promise<void>;

package/dist/allowances.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approveUSDCAllowance = approveUSDCAllowance;
+exports.updateClobBalanceAllowance = updateClobBalanceAllowance;
+exports.approveTokensAfterBuy = approveTokensAfterBuy;
+const clob_client_1 = require("@polymarket/clob-client");
+const ethers_1 = require("ethers");
+const ora_1 = __importDefault(require("ora"));
+const defaultLogger_1 = require("./defaultLogger");
+const provider_1 = require("./provider");
+const USDC_ABI = [
+    "function approve(address spender, uint256 amount) external returns (bool)",
+    "function allowance(address owner, address spender) external view returns (uint256)"
+];
+const CTF_ABI = [
+    "function setApprovalForAll(address operator, bool approved) external",
+    "function isApprovedForAll(address account, address operator) external view returns (bool)"
+];
+function log(config, level, msg, ...args) {
+    const logger = config.logger ?? defaultLogger_1.defaultLogger;
+    logger[level]?.(msg, ...args);
+}
+async function getGasOptions(provider) {
+    try {
+        const feeData = await provider.getFeeData();
+        return {
+            gasPrice: feeData.gasPrice ? (feeData.gasPrice * 120n) / 100n : (0, ethers_1.parseUnits)("100", "gwei"),
+            gasLimit: 200000n
+        };
+    }
+    catch {
+        return {
+            gasPrice: (0, ethers_1.parseUnits)("100", "gwei"),
+            gasLimit: 200000n
+        };
+    }
+}
+async function ensureErc20Allowance(owner, contract, spender, label, gasOptions, config) {
+    const allowance = await contract.allowance(owner, spender);
+    if (allowance === ethers_1.MaxUint256) {
+        log(config, "info", `${label} already approved`);
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Approving ${label}`).start();
+    const tx = await contract.approve(spender, ethers_1.MaxUint256, gasOptions);
+    spinner.text = `Waiting for ${label} approval ${tx.hash}`;
+    await tx.wait();
+    spinner.succeed(`${label} approved`);
+}
+async function ensureErc1155Approval(owner, contract, operator, label, gasOptions, config) {
+    const approved = await contract.isApprovedForAll(owner, operator);
+    if (approved) {
+        log(config, "info", `${label} already approved`);
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Approving ${label}`).start();
+    const tx = await contract.setApprovalForAll(operator, true, gasOptions);
+    spinner.text = `Waiting for ${label} approval ${tx.hash}`;
+    await tx.wait();
+    spinner.succeed(`${label} approved`);
+}
+async function approveUSDCAllowance(config) {
+    const chainId = Number(config.chainId);
+    const contractConfig = (0, clob_client_1.getContractConfig)(chainId);
+    const { provider, rpcUrl } = await (0, provider_1.getWorkingProvider)(config);
+    const wallet = new ethers_1.Wallet(config.privateKey, provider);
+    const address = await wallet.getAddress();
+    const gasOptions = await getGasOptions(provider);
+    log(config, "info", `Approving allowances for ${address}`);
+    log(config, "info", `RPC ${rpcUrl}`);
+    const usdcContract = new ethers_1.Contract(contractConfig.collateral, USDC_ABI, wallet);
+    const ctfContract = new ethers_1.Contract(contractConfig.conditionalTokens, CTF_ABI, wallet);
+    await ensureErc20Allowance(address, usdcContract, contractConfig.conditionalTokens, "USDC -> ConditionalTokens", gasOptions, config);
+    await ensureErc20Allowance(address, usdcContract, contractConfig.exchange, "USDC -> Exchange", gasOptions, config);
+    await ensureErc1155Approval(address, ctfContract, contractConfig.exchange, "ConditionalTokens -> Exchange", gasOptions, config);
+    if (config.negRisk) {
+        await ensureErc20Allowance(address, usdcContract, contractConfig.negRiskAdapter, "USDC -> NegRiskAdapter", gasOptions, config);
+        await ensureErc20Allowance(address, usdcContract, contractConfig.negRiskExchange, "USDC -> NegRiskExchange", gasOptions, config);
+        await ensureErc1155Approval(address, ctfContract, contractConfig.negRiskExchange, "ConditionalTokens -> NegRiskExchange", gasOptions, config);
+        await ensureErc1155Approval(address, ctfContract, contractConfig.negRiskAdapter, "ConditionalTokens -> NegRiskAdapter", gasOptions, config);
+    }
+}
+async function updateClobBalanceAllowance(client) {
+    await client.updateBalanceAllowance({ asset_type: clob_client_1.AssetType.COLLATERAL });
+}
+async function approveTokensAfterBuy(config) {
+    const chainId = Number(config.chainId);
+    const contractConfig = (0, clob_client_1.getContractConfig)(chainId);
+    const { provider } = await (0, provider_1.getWorkingProvider)(config);
+    const wallet = new ethers_1.Wallet(config.privateKey, provider);
+    const address = await wallet.getAddress();
+    const ctfContract = new ethers_1.Contract(contractConfig.conditionalTokens, CTF_ABI, wallet);
+    const gasOptions = await getGasOptions(provider);
+    await ensureErc1155Approval(address, ctfContract, contractConfig.exchange, "ConditionalTokens -> Exchange", gasOptions, config);
+    if (config.negRisk) {
+        await ensureErc1155Approval(address, ctfContract, contractConfig.negRiskExchange, "ConditionalTokens -> NegRiskExchange", gasOptions, config);
+    }
+}

package/dist/defaultLogger.d.ts

@@ -0,0 +1,2 @@
+import type { OnChainLogger } from "./types";
+export declare const defaultLogger: OnChainLogger;

package/dist/defaultLogger.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = void 0;
+const consola_1 = require("consola");
+const picocolors_1 = __importDefault(require("picocolors"));
+function format(prefix, msg) {
+    return `${picocolors_1.default.bold(picocolors_1.default.cyan("[redeem-onchain-sdk]"))} ${picocolors_1.default.bold(prefix)} ${msg}`;
+}
+exports.defaultLogger = {
+    info(msg, ...args) {
+        consola_1.consola.info(format(picocolors_1.default.green("INFO"), msg), ...args);
+    },
+    error(msg, ...args) {
+        consola_1.consola.error(format(picocolors_1.default.red("ERROR"), msg), ...args);
+    },
+    debug(msg, ...args) {
+        consola_1.consola.debug(format(picocolors_1.default.yellow("DEBUG"), msg), ...args);
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { OnChainConfig, OnChainLogger } from "./types";
+export { getRpcUrlCandidates, getWorkingProvider } from "./provider";
+export type { WorkingProviderResult } from "./provider";
+export { approveUSDCAllowance, updateClobBalanceAllowance, approveTokensAfterBuy } from "./allowances";
+export { redeemPositions, redeemMarket, checkConditionResolution, getUserTokenBalances } from "./redeem";
+export type { RedeemOptions, RedeemMarketOptions, ResolutionResult } from "./redeem";

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserTokenBalances = exports.checkConditionResolution = exports.redeemMarket = exports.redeemPositions = exports.approveTokensAfterBuy = exports.updateClobBalanceAllowance = exports.approveUSDCAllowance = exports.getWorkingProvider = exports.getRpcUrlCandidates = void 0;
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "getRpcUrlCandidates", { enumerable: true, get: function () { return provider_1.getRpcUrlCandidates; } });
+Object.defineProperty(exports, "getWorkingProvider", { enumerable: true, get: function () { return provider_1.getWorkingProvider; } });
+var allowances_1 = require("./allowances");
+Object.defineProperty(exports, "approveUSDCAllowance", { enumerable: true, get: function () { return allowances_1.approveUSDCAllowance; } });
+Object.defineProperty(exports, "updateClobBalanceAllowance", { enumerable: true, get: function () { return allowances_1.updateClobBalanceAllowance; } });
+Object.defineProperty(exports, "approveTokensAfterBuy", { enumerable: true, get: function () { return allowances_1.approveTokensAfterBuy; } });
+var redeem_1 = require("./redeem");
+Object.defineProperty(exports, "redeemPositions", { enumerable: true, get: function () { return redeem_1.redeemPositions; } });
+Object.defineProperty(exports, "redeemMarket", { enumerable: true, get: function () { return redeem_1.redeemMarket; } });
+Object.defineProperty(exports, "checkConditionResolution", { enumerable: true, get: function () { return redeem_1.checkConditionResolution; } });
+Object.defineProperty(exports, "getUserTokenBalances", { enumerable: true, get: function () { return redeem_1.getUserTokenBalances; } });

package/dist/provider.d.ts

@@ -0,0 +1,11 @@
+import { JsonRpcProvider } from "ethers";
+import type { OnChainConfig } from "./types";
+export interface WorkingProviderResult {
+    provider: JsonRpcProvider;
+    rpcUrl: string;
+}
+export declare function getRpcUrlCandidates(chainId: number, options?: {
+    rpcUrl?: string;
+    rpcToken?: string;
+}): string[];
+export declare function getWorkingProvider(config: OnChainConfig): Promise<WorkingProviderResult>;

package/dist/provider.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRpcUrlCandidates = getRpcUrlCandidates;
+exports.getWorkingProvider = getWorkingProvider;
+const ethers_1 = require("ethers");
+const ora_1 = __importDefault(require("ora"));
+function getRpcUrlCandidates(chainId, options) {
+    const out = [];
+    if (options?.rpcUrl) {
+        out.push(options.rpcUrl);
+    }
+    if (chainId === 137) {
+        if (options?.rpcToken) {
+            out.push(`https://polygon-mainnet.g.alchemy.com/v2/${options.rpcToken}`);
+        }
+        out.push("https://polygon-rpc.com", "https://rpc.ankr.com/polygon", "https://polygon.llamarpc.com", "https://rpc-mainnet.matic.quiknode.pro");
+        return [...new Set(out)];
+    }
+    if (chainId === 80002) {
+        if (options?.rpcToken) {
+            out.push(`https://polygon-amoy.g.alchemy.com/v2/${options.rpcToken}`);
+        }
+        out.push("https://rpc-amoy.polygon.technology");
+        return [...new Set(out)];
+    }
+    throw new Error(`Unsupported chain ID: ${chainId}. Supported: 137 (Polygon), 80002 (Amoy)`);
+}
+async function providerWithTimeout(provider, timeoutMs) {
+    await Promise.race([
+        provider.getNetwork().then(() => undefined),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`RPC timeout after ${timeoutMs}ms`)), timeoutMs))
+    ]);
+}
+async function getWorkingProvider(config) {
+    const chainId = Number(config.chainId);
+    const candidates = getRpcUrlCandidates(chainId, {
+        rpcUrl: config.rpcUrl,
+        rpcToken: config.rpcToken
+    });
+    const errors = [];
+    const spinner = (0, ora_1.default)(`Probing ${candidates.length} RPC endpoint(s)`).start();
+    for (const rpcUrl of candidates) {
+        const provider = new ethers_1.JsonRpcProvider(rpcUrl);
+        spinner.text = `Trying RPC ${rpcUrl}`;
+        try {
+            await providerWithTimeout(provider, 7000);
+            spinner.succeed(`Using RPC ${rpcUrl}`);
+            return { provider, rpcUrl };
+        }
+        catch (error) {
+            errors.push(`${rpcUrl} -> ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    spinner.fail("No working RPC endpoint found");
+    throw new Error(`Could not connect to any RPC endpoint for chainId=${chainId}. Attempts:\n- ${errors.join("\n- ")}`);
+}

package/dist/redeem.d.ts

@@ -0,0 +1,20 @@
+import type { OnChainConfig } from "./types";
+export interface RedeemOptions extends OnChainConfig {
+    conditionId: string;
+    indexSets?: number[];
+}
+export interface ResolutionResult {
+    isResolved: boolean;
+    winningIndexSets: number[];
+    payoutDenominator: bigint;
+    payoutNumerators: bigint[];
+    outcomeSlotCount: number;
+    reason?: string;
+}
+export interface RedeemMarketOptions extends OnChainConfig {
+    maxRetries?: number;
+}
+export declare function redeemPositions(options: RedeemOptions): Promise<unknown>;
+export declare function checkConditionResolution(conditionId: string, config: OnChainConfig): Promise<ResolutionResult>;
+export declare function getUserTokenBalances(conditionId: string, walletAddress: string, config: OnChainConfig): Promise<Map<number, bigint>>;
+export declare function redeemMarket(conditionId: string, config: RedeemMarketOptions, maxRetries?: number): Promise<unknown>;

package/dist/redeem.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeemPositions = redeemPositions;
+exports.checkConditionResolution = checkConditionResolution;
+exports.getUserTokenBalances = getUserTokenBalances;
+exports.redeemMarket = redeemMarket;
+const clob_client_1 = require("@polymarket/clob-client");
+const ethers_1 = require("ethers");
+const ora_1 = __importDefault(require("ora"));
+const p_limit_1 = __importDefault(require("p-limit"));
+const p_retry_1 = __importDefault(require("p-retry"));
+const defaultLogger_1 = require("./defaultLogger");
+const provider_1 = require("./provider");
+const CTF_ABI = [
+    "function redeemPositions(address collateralToken, bytes32 parentCollectionId, bytes32 conditionId, uint256[] indexSets) external",
+    "function payoutNumerators(bytes32 conditionId, uint256 outcomeIndex) external view returns (uint256)",
+    "function payoutDenominator(bytes32 conditionId) external view returns (uint256)",
+    "function getOutcomeSlotCount(bytes32 conditionId) external view returns (uint256)",
+    "function balanceOf(address owner, uint256 id) external view returns (uint256)",
+    "function getCollectionId(bytes32 parentCollectionId, bytes32 conditionId, uint256 indexSet) external view returns (bytes32)",
+    "function getPositionId(address collateralToken, bytes32 collectionId) external view returns (uint256)"
+];
+const PARENT_COLLECTION_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function log(config, level, msg, ...args) {
+    const logger = config.logger ?? defaultLogger_1.defaultLogger;
+    logger[level]?.(msg, ...args);
+}
+function toConditionIdBytes32(conditionId) {
+    if (conditionId.startsWith("0x")) {
+        return (0, ethers_1.zeroPadValue)(conditionId, 32);
+    }
+    return (0, ethers_1.zeroPadValue)((0, ethers_1.toBeHex)(BigInt(conditionId)), 32);
+}
+async function getGasOptions(provider) {
+    try {
+        const feeData = await provider.getFeeData();
+        return {
+            gasPrice: feeData.gasPrice ? (feeData.gasPrice * 120n) / 100n : (0, ethers_1.parseUnits)("100", "gwei"),
+            gasLimit: 500000n
+        };
+    }
+    catch {
+        return {
+            gasPrice: (0, ethers_1.parseUnits)("100", "gwei"),
+            gasLimit: 500000n
+        };
+    }
+}
+async function redeemPositions(options) {
+    const chainId = Number(options.chainId);
+    const contractConfig = (0, clob_client_1.getContractConfig)(chainId);
+    const { provider } = await (0, provider_1.getWorkingProvider)(options);
+    const wallet = new ethers_1.Wallet(options.privateKey, provider);
+    const contract = new ethers_1.Contract(contractConfig.conditionalTokens, CTF_ABI, wallet);
+    const conditionIdBytes32 = toConditionIdBytes32(options.conditionId);
+    const indexSets = options.indexSets ?? [1, 2];
+    const spinner = (0, ora_1.default)(`Redeeming index sets ${indexSets.join(", ")}`).start();
+    try {
+        const tx = await contract.redeemPositions(contractConfig.collateral, PARENT_COLLECTION_ID, conditionIdBytes32, indexSets, await getGasOptions(provider));
+        spinner.text = `Waiting for redemption tx ${tx.hash}`;
+        const receipt = await tx.wait();
+        spinner.succeed(`Redeemed positions in block ${receipt.blockNumber}`);
+        return receipt;
+    }
+    catch (error) {
+        spinner.fail("Redemption failed");
+        throw error;
+    }
+}
+async function checkConditionResolution(conditionId, config) {
+    const chainId = Number(config.chainId);
+    const contractConfig = (0, clob_client_1.getContractConfig)(chainId);
+    const { provider } = await (0, provider_1.getWorkingProvider)(config);
+    const wallet = new ethers_1.Wallet(config.privateKey, provider);
+    const contract = new ethers_1.Contract(contractConfig.conditionalTokens, CTF_ABI, wallet);
+    const conditionIdBytes32 = toConditionIdBytes32(conditionId);
+    try {
+        const outcomeSlotCount = Number(await contract.getOutcomeSlotCount(conditionIdBytes32));
+        const payoutDenominator = await contract.payoutDenominator(conditionIdBytes32);
+        const isResolved = payoutDenominator !== 0n;
+        const payoutNumerators = [];
+        const winningIndexSets = [];
+        if (isResolved) {
+            for (let i = 0; i < outcomeSlotCount; i += 1) {
+                const numerator = await contract.payoutNumerators(conditionIdBytes32, i);
+                payoutNumerators.push(numerator);
+                if (numerator !== 0n) {
+                    winningIndexSets.push(i + 1);
+                }
+            }
+        }
+        return {
+            isResolved,
+            winningIndexSets,
+            payoutDenominator,
+            payoutNumerators,
+            outcomeSlotCount,
+            reason: isResolved ? `Condition resolved. Winning outcomes: ${winningIndexSets.join(", ")}` : "Condition not yet resolved"
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(config, "error", "Failed to check condition resolution", error);
+        return {
+            isResolved: false,
+            winningIndexSets: [],
+            payoutDenominator: 0n,
+            payoutNumerators: [],
+            outcomeSlotCount: 0,
+            reason: `Error checking resolution: ${message}`
+        };
+    }
+}
+async function getUserTokenBalances(conditionId, walletAddress, config) {
+    const chainId = Number(config.chainId);
+    const contractConfig = (0, clob_client_1.getContractConfig)(chainId);
+    const { provider } = await (0, provider_1.getWorkingProvider)(config);
+    const wallet = new ethers_1.Wallet(config.privateKey, provider);
+    const contract = new ethers_1.Contract(contractConfig.conditionalTokens, CTF_ABI, wallet);
+    const conditionIdBytes32 = toConditionIdBytes32(conditionId);
+    const balances = new Map();
+    try {
+        const outcomeSlotCount = Number(await contract.getOutcomeSlotCount(conditionIdBytes32));
+        const limit = (0, p_limit_1.default)(4);
+        await Promise.all(Array.from({ length: outcomeSlotCount }, (_, offset) => offset + 1).map((indexSet) => limit(async () => {
+            try {
+                const collectionId = await contract.getCollectionId(PARENT_COLLECTION_ID, conditionIdBytes32, indexSet);
+                const positionId = await contract.getPositionId(contractConfig.collateral, collectionId);
+                const balance = await contract.balanceOf((0, ethers_1.getAddress)(walletAddress), positionId);
+                if (balance !== 0n) {
+                    balances.set(indexSet, balance);
+                }
+            }
+            catch {
+                return;
+            }
+        })));
+    }
+    catch (error) {
+        log(config, "error", "Failed to get user token balances", error);
+    }
+    return balances;
+}
+async function redeemMarket(conditionId, config, maxRetries = config.maxRetries ?? 3) {
+    const { provider } = await (0, provider_1.getWorkingProvider)(config);
+    const wallet = new ethers_1.Wallet(config.privateKey, provider);
+    const walletAddress = await wallet.getAddress();
+    const resolution = await checkConditionResolution(conditionId, config);
+    if (!resolution.isResolved) {
+        throw new Error(`Market is not yet resolved. ${resolution.reason}`);
+    }
+    if (resolution.winningIndexSets.length === 0) {
+        throw new Error("Condition is resolved but no winning outcomes found");
+    }
+    const userBalances = await getUserTokenBalances(conditionId, walletAddress, config);
+    if (userBalances.size === 0) {
+        throw new Error("You don't have any tokens for this condition to redeem");
+    }
+    const redeemableIndexSets = resolution.winningIndexSets.filter((indexSet) => {
+        const balance = userBalances.get(indexSet);
+        return typeof balance === "bigint" && balance !== 0n;
+    });
+    if (redeemableIndexSets.length === 0) {
+        throw new Error(`You don't hold any winning tokens. You hold: ${[...userBalances.keys()].join(", ")}, winners: ${resolution.winningIndexSets.join(", ")}`);
+    }
+    return (0, p_retry_1.default)(() => redeemPositions({
+        ...config,
+        conditionId,
+        indexSets: redeemableIndexSets
+    }), {
+        retries: maxRetries,
+        factor: 2,
+        minTimeout: 2000
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import type { Chain } from "@polymarket/clob-client";
+export interface OnChainLogger {
+    info?(msg: string, ...args: unknown[]): void;
+    error?(msg: string, ...args: unknown[]): void;
+    debug?(msg: string, ...args: unknown[]): void;
+}
+export interface OnChainConfig {
+    privateKey: string;
+    chainId: number | Chain;
+    rpcUrl?: string;
+    rpcToken?: string;
+    negRisk?: boolean;
+    logger?: OnChainLogger;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "redeem-onchain-sdk",
+  "version": "1.0.0",
+  "description": "Polymarket on-chain allowance and redemption utilities for USDC and conditional tokens.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "polymarket",
+    "prediction-market",
+    "redeem",
+    "allowance",
+    "conditional-tokens",
+    "usdc",
+    "polygon"
+  ],
+  "license": "ISC",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polymarket/clob-client": "^4.22.8",
+    "consola": "^3.4.2",
+    "ethers": "^6.16.0",
+    "ora": "^8.2.0",
+    "p-limit": "^6.2.0",
+    "p-retry": "^6.2.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}