@rateloop/contracts 0.1.0

package/dist/cjs/deployments.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedDeployment = getSharedDeployment;
+exports.getSharedDeploymentAddress = getSharedDeploymentAddress;
+exports.getSharedChainStartBlock = getSharedChainStartBlock;
+exports.getSharedDeploymentStartBlock = getSharedDeploymentStartBlock;
+const viem_1 = require("viem");
+const deployedContracts_1 = __importDefault(require("./deployedContracts"));
+const sharedDeployments = deployedContracts_1.default;
+function isValidStartBlock(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function getSharedDeployment(chainId, contractName) {
+    return sharedDeployments[chainId]?.[contractName];
+}
+function getSharedDeploymentAddress(chainId, contractName) {
+    const address = getSharedDeployment(chainId, contractName)?.address;
+    if (!address || !(0, viem_1.isAddress)(address)) {
+        return undefined;
+    }
+    return address;
+}
+function getSharedChainStartBlock(chainId) {
+    const contracts = sharedDeployments[chainId];
+    if (!contracts) {
+        return undefined;
+    }
+    const deployedBlocks = Object.values(contracts)
+        .map(contract => contract?.deployedOnBlock)
+        .filter(isValidStartBlock);
+    if (deployedBlocks.length === 0) {
+        return undefined;
+    }
+    return Math.min(...deployedBlocks);
+}
+function getSharedDeploymentStartBlock(chainId, contractName) {
+    const contractStartBlock = getSharedDeployment(chainId, contractName)?.deployedOnBlock;
+    if (isValidStartBlock(contractStartBlock)) {
+        return contractStartBlock;
+    }
+    if (!getSharedDeployment(chainId, contractName)) {
+        return undefined;
+    }
+    return getSharedChainStartBlock(chainId);
+}

package/dist/cjs/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployedContracts = void 0;
+__exportStar(require("./abis/index"), exports);
+__exportStar(require("./deployments"), exports);
+var deployedContracts_1 = require("./deployedContracts");
+Object.defineProperty(exports, "deployedContracts", { enumerable: true, get: function () { return __importDefault(deployedContracts_1).default; } });
+__exportStar(require("./protocol"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./voting"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/protocol.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOUNTY_ELIGIBILITY_RECENT_RECHECK_FLAG = exports.BOUNTY_ELIGIBILITY_CREDENTIAL_MASK = exports.WORLD_CHAIN_USDC_BY_CHAIN_ID = exports.WORLD_ID_V3_ROUTER_BY_CHAIN_ID = exports.USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID = exports.USDC_BY_CHAIN_ID = exports.MIN_NONZERO_CONFIDENTIALITY_BOND = exports.CONFIDENTIALITY_FLAG_PRIVATE_FOREVER = exports.QUESTION_REWARD_PARTICIPANT_FLOORS = exports.SCORE_SPREAD_POLICY = exports.REWARD_SPLIT_BPS = exports.PLATFORM_REWARD_SPLIT_BPS = exports.EPOCH_WEIGHT_BPS = exports.REVEAL_FAILED_GRACE_MULTIPLIER = exports.DEFAULT_REVEAL_GRACE_PERIOD_SECONDS = exports.DEFAULT_ROUND_CONFIG = exports.ROUND_STATE_LABEL = exports.ROUND_STATE = exports.USER_PREDICTION_PERCENT = exports.USER_PREDICTION_BPS = exports.BPS_SCALE = void 0;
+exports.requiredQuestionRewardParticipants = requiredQuestionRewardParticipants;
+exports.getUsdcEip712DomainName = getUsdcEip712DomainName;
+exports.BPS_SCALE = 10_000;
+exports.USER_PREDICTION_BPS = {
+    min: 100,
+    max: 9_900,
+};
+exports.USER_PREDICTION_PERCENT = {
+    min: exports.USER_PREDICTION_BPS.min / 100,
+    max: exports.USER_PREDICTION_BPS.max / 100,
+};
+exports.ROUND_STATE = {
+    Open: 0,
+    Settled: 1,
+    Cancelled: 2,
+    Tied: 3,
+    RevealFailed: 4,
+};
+exports.ROUND_STATE_LABEL = {
+    [exports.ROUND_STATE.Open]: "Open",
+    [exports.ROUND_STATE.Settled]: "Settled",
+    [exports.ROUND_STATE.Cancelled]: "Cancelled",
+    [exports.ROUND_STATE.Tied]: "Tied",
+    [exports.ROUND_STATE.RevealFailed]: "RevealFailed",
+};
+exports.DEFAULT_ROUND_CONFIG = {
+    epochDurationSeconds: 20 * 60,
+    maxDurationSeconds: 20 * 60,
+    minVoters: 3,
+    maxVoters: 100,
+};
+exports.DEFAULT_REVEAL_GRACE_PERIOD_SECONDS = 60 * 60;
+/** Matches `RoundCleanupLib.REVEAL_FAILED_GRACE_MULTIPLIER` in foundry. */
+exports.REVEAL_FAILED_GRACE_MULTIPLIER = 24;
+exports.EPOCH_WEIGHT_BPS = {
+    blind: exports.BPS_SCALE,
+    informed: 2_500,
+};
+exports.PLATFORM_REWARD_SPLIT_BPS = {
+    frontend: 300,
+};
+exports.REWARD_SPLIT_BPS = {
+    voter: 9_600,
+    submitter: 0,
+    platform: exports.PLATFORM_REWARD_SPLIT_BPS.frontend,
+    treasury: 100,
+};
+exports.SCORE_SPREAD_POLICY = {
+    intensityBps: 15_000,
+    forfeitMinReveals: 8,
+    maxForfeitBps: 5_000,
+};
+exports.QUESTION_REWARD_PARTICIPANT_FLOORS = {
+    minParticipants: 3,
+    highValueAmount: 1_000_000_000,
+    highValueMinParticipants: 5,
+    veryHighValueAmount: 10_000_000_000,
+    veryHighValueMinParticipants: exports.SCORE_SPREAD_POLICY.forfeitMinReveals,
+};
+function requiredQuestionRewardParticipants(amountAtomic) {
+    const amount = typeof amountAtomic === "bigint" ? amountAtomic : BigInt(amountAtomic);
+    if (amount >= BigInt(exports.QUESTION_REWARD_PARTICIPANT_FLOORS.veryHighValueAmount)) {
+        return exports.QUESTION_REWARD_PARTICIPANT_FLOORS.veryHighValueMinParticipants;
+    }
+    if (amount >= BigInt(exports.QUESTION_REWARD_PARTICIPANT_FLOORS.highValueAmount)) {
+        return exports.QUESTION_REWARD_PARTICIPANT_FLOORS.highValueMinParticipants;
+    }
+    return exports.QUESTION_REWARD_PARTICIPANT_FLOORS.minParticipants;
+}
+exports.CONFIDENTIALITY_FLAG_PRIVATE_FOREVER = 1;
+exports.MIN_NONZERO_CONFIDENTIALITY_BOND = 1000000n;
+exports.USDC_BY_CHAIN_ID = {
+    8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    480: "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1",
+    4801: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+};
+exports.USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID = {
+    8453: "USD Coin",
+    84532: "USDC",
+    480: "USDC",
+    4801: "USDC",
+};
+function getUsdcEip712DomainName(chainId) {
+    return exports.USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID[chainId] ?? "USDC";
+}
+exports.WORLD_ID_V3_ROUTER_BY_CHAIN_ID = {
+    8453: "0xBCC7e5910178AFFEEeBA573ba6903E9869594163",
+    84532: "0x42FF98C4E85212a5D31358ACbFe76a621b50fC02",
+    480: "0x17B354dD2595411ff79041f930e491A4Df39A278",
+    4801: "0x57f928158C3EE7CDad1e4D8642503c4D0201f611",
+};
+/** @deprecated Use `USDC_BY_CHAIN_ID`; retained while downstream packages migrate names. */
+exports.WORLD_CHAIN_USDC_BY_CHAIN_ID = exports.USDC_BY_CHAIN_ID;
+exports.BOUNTY_ELIGIBILITY_CREDENTIAL_MASK = 0x0e;
+exports.BOUNTY_ELIGIBILITY_RECENT_RECHECK_FLAG = 0x80;

package/dist/cjs/types.js

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

package/dist/cjs/voting.js

@@ -0,0 +1,336 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackVoteRoundContext = exports.predictionPercentToBps = exports.parseTlockCiphertextMetadata = exports.packVoteRoundContext = exports.normalizePredictedUpBps = exports.encodeRbtsVotePlaintext = exports.deriveVoteTlockRevealAvailableAtSeconds = exports.decodeRbtsVotePlaintext = exports.buildRbtsCommitHash = exports.buildCommitKey = exports.buildCommitHash = exports.bpsToPredictionPercent = exports.MIN_PREDICTED_UP_PERCENT = exports.MIN_PREDICTED_UP_BPS = exports.MAX_PREDICTED_UP_PERCENT = exports.MAX_PREDICTED_UP_BPS = void 0;
+exports.getVoteTlockChainInfo = getVoteTlockChainInfo;
+exports.tlockEncryptVote = tlockEncryptVote;
+exports.decryptTlockVoteCiphertext = decryptTlockVoteCiphertext;
+exports.createTlockVoteCommit = createTlockVoteCommit;
+exports.createTlockRbtsVoteCommit = createTlockRbtsVoteCommit;
+const viem_1 = require("viem");
+const votingCore_1 = require("./votingCore");
+var votingCore_2 = require("./votingCore");
+Object.defineProperty(exports, "MAX_PREDICTED_UP_BPS", { enumerable: true, get: function () { return votingCore_2.MAX_PREDICTED_UP_BPS; } });
+Object.defineProperty(exports, "MAX_PREDICTED_UP_PERCENT", { enumerable: true, get: function () { return votingCore_2.MAX_PREDICTED_UP_PERCENT; } });
+Object.defineProperty(exports, "MIN_PREDICTED_UP_BPS", { enumerable: true, get: function () { return votingCore_2.MIN_PREDICTED_UP_BPS; } });
+Object.defineProperty(exports, "MIN_PREDICTED_UP_PERCENT", { enumerable: true, get: function () { return votingCore_2.MIN_PREDICTED_UP_PERCENT; } });
+Object.defineProperty(exports, "bpsToPredictionPercent", { enumerable: true, get: function () { return votingCore_2.bpsToPredictionPercent; } });
+Object.defineProperty(exports, "buildCommitHash", { enumerable: true, get: function () { return votingCore_2.buildCommitHash; } });
+Object.defineProperty(exports, "buildCommitKey", { enumerable: true, get: function () { return votingCore_2.buildCommitKey; } });
+Object.defineProperty(exports, "buildRbtsCommitHash", { enumerable: true, get: function () { return votingCore_2.buildRbtsCommitHash; } });
+Object.defineProperty(exports, "decodeRbtsVotePlaintext", { enumerable: true, get: function () { return votingCore_2.decodeRbtsVotePlaintext; } });
+Object.defineProperty(exports, "deriveVoteTlockRevealAvailableAtSeconds", { enumerable: true, get: function () { return votingCore_2.deriveVoteTlockRevealAvailableAtSeconds; } });
+Object.defineProperty(exports, "encodeRbtsVotePlaintext", { enumerable: true, get: function () { return votingCore_2.encodeRbtsVotePlaintext; } });
+Object.defineProperty(exports, "normalizePredictedUpBps", { enumerable: true, get: function () { return votingCore_2.normalizePredictedUpBps; } });
+Object.defineProperty(exports, "packVoteRoundContext", { enumerable: true, get: function () { return votingCore_2.packVoteRoundContext; } });
+Object.defineProperty(exports, "parseTlockCiphertextMetadata", { enumerable: true, get: function () { return votingCore_2.parseTlockCiphertextMetadata; } });
+Object.defineProperty(exports, "predictionPercentToBps", { enumerable: true, get: function () { return votingCore_2.predictionPercentToBps; } });
+Object.defineProperty(exports, "unpackVoteRoundContext", { enumerable: true, get: function () { return votingCore_2.unpackVoteRoundContext; } });
+let tlockModulePromise;
+const AGE_ARMOR_HEADER = "-----BEGIN AGE ENCRYPTED FILE-----";
+const AGE_ARMOR_FOOTER = "-----END AGE ENCRYPTED FILE-----";
+const MIN_ENCRYPTED_BODY_LENGTH = 65;
+const MAINNET_QUICKNET_CHAIN_HASH = "52db9ba70e0cc0f6eaf7803dd07447a1f5477735fd3f661792ba94600c84e971";
+const TLOCK_JS_TESTNET_CHAIN_HASH = "7672797f548f3f4748ac4bf3352fc6c6b6468c9ad40ad456a397545c6e2df5bf";
+const QUICKNET_T_CHAIN = {
+    url: "https://testnet-api.drand.cloudflare.com/cc9c398442737cbd141526600919edd69f1d6f9b4adb67e4d912fbc64341a9a5",
+    chainHash: "cc9c398442737cbd141526600919edd69f1d6f9b4adb67e4d912fbc64341a9a5",
+    publicKey: "b15b65b46fb29104f6a4b5d1e11a8da6344463973d423661bb0804846a0ecd1ef93c25057f1c0baab2ac53e56c662b66072f6d84ee791a3382bfb055afab1e6a375538d8ffc451104ac971d2dc9b168e2d3246b0be2015969cbaac298f6502da",
+};
+const RATELOOP_TLOCK_USER_AGENT = "rateloop-tlock";
+async function loadTlockModule() {
+    tlockModulePromise ??= Promise.resolve().then(() => __importStar(require("tlock-js"))).then((module) => ({
+        HttpCachingChain: module.HttpCachingChain,
+        HttpChainClient: module.HttpChainClient,
+        mainnetClient: module.mainnetClient,
+        testnetClient: module.testnetClient,
+        timelockEncrypt: module.timelockEncrypt,
+        timelockDecrypt: module.timelockDecrypt,
+    }));
+    return tlockModulePromise;
+}
+function normalizeDrandChainHash(hash) {
+    if (!hash)
+        return null;
+    const normalized = hash.toLowerCase();
+    if (!/^0x[0-9a-f]{64}$/u.test(normalized)) {
+        throw new Error("Invalid drand chain hash");
+    }
+    return normalized.slice(2);
+}
+function normalizeOptionalPositiveBigInt(value, label) {
+    if (value == null)
+        return null;
+    const normalized = typeof value === "bigint" ? value : BigInt(Math.trunc(value));
+    if (normalized <= 0n) {
+        throw new Error(`Invalid drand ${label}`);
+    }
+    return normalized;
+}
+function createHttpTlockClient(tlockModule, chain) {
+    const options = {
+        disableBeaconVerification: false,
+        noCache: false,
+        chainVerificationParams: {
+            chainHash: chain.chainHash,
+            publicKey: chain.publicKey,
+        },
+    };
+    const httpChain = new tlockModule.HttpCachingChain(chain.url, options);
+    return new tlockModule.HttpChainClient(httpChain, options, {
+        userAgent: RATELOOP_TLOCK_USER_AGENT,
+    });
+}
+function resolveTlockClientForRuntime(tlockModule, runtime = {}) {
+    if (runtime.client) {
+        return runtime.client;
+    }
+    const expectedHash = normalizeDrandChainHash(runtime.drandChainHash);
+    if (!expectedHash || expectedHash === MAINNET_QUICKNET_CHAIN_HASH) {
+        return tlockModule.mainnetClient();
+    }
+    if (expectedHash === QUICKNET_T_CHAIN.chainHash) {
+        return createHttpTlockClient(tlockModule, QUICKNET_T_CHAIN);
+    }
+    if (expectedHash === TLOCK_JS_TESTNET_CHAIN_HASH) {
+        return tlockModule.testnetClient();
+    }
+    throw new Error(`Unsupported drand chain 0x${expectedHash}. Update ProtocolConfig to drand quicknet or quicknet-t before voting.`);
+}
+function assertTlockChainInfoMatchesRuntime(chainInfo, runtime = {}) {
+    const expectedHash = normalizeDrandChainHash(runtime.drandChainHash);
+    if (!expectedHash)
+        return;
+    const actualHash = chainInfo.hash.toLowerCase();
+    if (actualHash !== expectedHash) {
+        throw new Error(`Tlock client chain 0x${actualHash} does not match vote round drand chain 0x${expectedHash}.`);
+    }
+    const expectedGenesisTime = normalizeOptionalPositiveBigInt(runtime.drandGenesisTimeSeconds, "genesis time");
+    if (expectedGenesisTime != null &&
+        BigInt(chainInfo.genesis_time) !== expectedGenesisTime) {
+        throw new Error(`Tlock client genesis ${chainInfo.genesis_time} does not match vote round drand genesis ${expectedGenesisTime.toString()}.`);
+    }
+    const expectedPeriod = normalizeOptionalPositiveBigInt(runtime.drandPeriodSeconds, "period");
+    if (expectedPeriod != null && BigInt(chainInfo.period) !== expectedPeriod) {
+        throw new Error(`Tlock client period ${chainInfo.period} does not match vote round drand period ${expectedPeriod.toString()}.`);
+    }
+}
+async function getVoteTlockChainInfo(runtime = {}) {
+    const tlockModule = await loadTlockModule();
+    const client = resolveTlockClientForRuntime(tlockModule, runtime);
+    const chainInfo = await client.chain().info();
+    assertTlockChainInfoMatchesRuntime(chainInfo, runtime);
+    return {
+        periodSeconds: BigInt(chainInfo.period),
+        genesisTimeSeconds: BigInt(chainInfo.genesis_time),
+        drandChainHash: `0x${chainInfo.hash.toLowerCase()}`,
+    };
+}
+async function createTlockVoteArtifacts(isUp, predictedUpBps, salt, epochDurationSeconds, runtime = {}) {
+    const tlockModule = await loadTlockModule();
+    const { timelockEncrypt } = tlockModule;
+    const client = resolveTlockClientForRuntime(tlockModule, runtime);
+    const now = runtime.now ?? Date.now;
+    const encryptFn = runtime.encryptFn ?? timelockEncrypt;
+    const chainInfo = await client.chain().info();
+    assertTlockChainInfoMatchesRuntime(chainInfo, runtime);
+    const targetRound = runtime.targetRound != null
+        ? normalizeTlockTargetRound(runtime.targetRound)
+        : deriveAcceptedTlockTargetRound(now(), epochDurationSeconds, chainInfo, runtime.roundStartTimeSeconds, runtime.candidateTimestampOffsetsSeconds);
+    const armored = await encryptFn(targetRound, (0, votingCore_1.encodeRbtsVotePlaintext)(isUp, predictedUpBps, salt), client);
+    const ciphertext = (0, viem_1.stringToHex)(armored);
+    return {
+        ciphertext,
+        ciphertextHash: (0, viem_1.keccak256)(ciphertext),
+        targetRound: BigInt(targetRound),
+        drandChainHash: `0x${chainInfo.hash.toLowerCase()}`,
+    };
+}
+function roundAtOrAfter(targetTimeMs, chainInfo) {
+    if (!Number.isFinite(targetTimeMs)) {
+        throw new Error("Cannot use Infinity or NaN as a beacon time");
+    }
+    const genesisTimeMs = chainInfo.genesis_time * 1000;
+    const periodMs = chainInfo.period * 1000;
+    if (!Number.isFinite(genesisTimeMs) ||
+        !Number.isFinite(periodMs) ||
+        periodMs <= 0) {
+        throw new Error("Invalid tlock chain timing");
+    }
+    if (targetTimeMs < genesisTimeMs) {
+        throw new Error("Cannot request a round before the genesis time");
+    }
+    return Math.ceil((targetTimeMs - genesisTimeMs) / periodMs) + 1;
+}
+function roundAt(targetTimeMs, chainInfo) {
+    const genesisTimeMs = chainInfo.genesis_time * 1000;
+    const periodMs = chainInfo.period * 1000;
+    if (!Number.isFinite(genesisTimeMs) ||
+        !Number.isFinite(periodMs) ||
+        periodMs <= 0) {
+        throw new Error("Invalid tlock chain timing");
+    }
+    if (targetTimeMs < genesisTimeMs) {
+        throw new Error("Cannot request a round before the genesis time");
+    }
+    return Math.floor((targetTimeMs - genesisTimeMs) / periodMs) + 1;
+}
+function normalizeRoundStartTimeMs(roundStartTimeSeconds) {
+    if (roundStartTimeSeconds == null)
+        return null;
+    const normalized = typeof roundStartTimeSeconds === "bigint"
+        ? Number(roundStartTimeSeconds)
+        : Number(roundStartTimeSeconds);
+    if (!Number.isFinite(normalized) || normalized <= 0)
+        return null;
+    return Math.floor(normalized) * 1000;
+}
+function deriveRevealableAfterMs(commitTimeMs, epochDurationSeconds, roundStartTimeMs) {
+    const epochDurationMs = Math.max(1, Math.floor(epochDurationSeconds)) * 1000;
+    const anchorTimeMs = roundStartTimeMs ?? commitTimeMs;
+    const elapsedMs = Math.max(0, commitTimeMs - anchorTimeMs);
+    const epochIndex = Math.floor(elapsedMs / epochDurationMs);
+    return anchorTimeMs + (epochIndex + 1) * epochDurationMs;
+}
+function deriveAcceptedTlockTargetRound(nowMs, epochDurationSeconds, chainInfo, roundStartTimeSeconds, candidateTimestampOffsetsSeconds) {
+    if (!Number.isFinite(nowMs)) {
+        throw new Error("Cannot use Infinity or NaN as a beacon time");
+    }
+    const roundStartTimeMs = normalizeRoundStartTimeMs(roundStartTimeSeconds);
+    const drandPeriodMs = Math.max(1, Math.floor(chainInfo.period)) * 1000;
+    const candidateOffsets = candidateTimestampOffsetsSeconds &&
+        candidateTimestampOffsetsSeconds.length > 0
+        ? candidateTimestampOffsetsSeconds
+        : buildDefaultCandidateTimestampOffsetsSeconds(chainInfo.period);
+    let minAcceptedTargetRound = 0;
+    let maxAcceptedTargetRound = 0;
+    for (const offsetSeconds of candidateOffsets) {
+        const commitTimeMs = nowMs + Math.floor(offsetSeconds) * 1000;
+        const revealableAfterMs = deriveRevealableAfterMs(commitTimeMs, epochDurationSeconds, roundStartTimeMs);
+        const minTargetRound = roundAtOrAfter(revealableAfterMs, chainInfo);
+        const maxTargetRound = roundAt(revealableAfterMs + 2 * drandPeriodMs, chainInfo);
+        if (minTargetRound <= 0 ||
+            maxTargetRound <= 0 ||
+            minTargetRound > maxTargetRound) {
+            throw new Error("No valid drand target round for the commit window");
+        }
+        minAcceptedTargetRound = Math.max(minAcceptedTargetRound, minTargetRound);
+        maxAcceptedTargetRound =
+            maxAcceptedTargetRound === 0
+                ? maxTargetRound
+                : Math.min(maxAcceptedTargetRound, maxTargetRound);
+    }
+    if (minAcceptedTargetRound === 0 ||
+        minAcceptedTargetRound > maxAcceptedTargetRound) {
+        throw new Error("No shared drand target round for commit windows");
+    }
+    return maxAcceptedTargetRound;
+}
+function buildDefaultCandidateTimestampOffsetsSeconds(drandPeriodSeconds) {
+    const safePeriodSeconds = Math.max(1, Math.floor(drandPeriodSeconds));
+    return Array.from({ length: safePeriodSeconds }, (_, index) => index);
+}
+function normalizeTlockTargetRound(targetRound) {
+    const normalized = typeof targetRound === "bigint"
+        ? Number(targetRound)
+        : Number.isInteger(targetRound)
+            ? targetRound
+            : Number.NaN;
+    if (!Number.isSafeInteger(normalized) || normalized <= 0) {
+        throw new Error("targetRound must be a positive safe integer");
+    }
+    return normalized;
+}
+async function tlockEncryptVote(isUp, predictedUpBps, salt, epochDurationSeconds, runtime = {}) {
+    const { ciphertext } = await createTlockVoteArtifacts(isUp, predictedUpBps, salt, epochDurationSeconds, runtime);
+    return ciphertext;
+}
+async function decryptTlockVoteCiphertext(ciphertext, runtime = {}) {
+    const tlockModule = await loadTlockModule();
+    const { timelockDecrypt } = tlockModule;
+    const client = resolveTlockClientForRuntime(tlockModule, runtime);
+    const decryptFn = runtime.decryptFn ?? timelockDecrypt;
+    const armored = (0, viem_1.hexToString)(ciphertext);
+    // Cheap structural sanity check before handing the payload to the tlock library.
+    // The age armor header alone is ~36 chars and the smallest valid body is bounded by
+    // MIN_ENCRYPTED_BODY_LENGTH, so anything shorter than the armor framing + body
+    // floor cannot plausibly decrypt to our 36-byte RBTS plaintext.
+    if (armored.length <
+        AGE_ARMOR_HEADER.length +
+            AGE_ARMOR_FOOTER.length +
+            MIN_ENCRYPTED_BODY_LENGTH) {
+        return null;
+    }
+    if (!armored.includes(AGE_ARMOR_HEADER) ||
+        !armored.includes(AGE_ARMOR_FOOTER)) {
+        return null;
+    }
+    if (runtime.drandChainHash) {
+        const chainInfo = await client.chain().info();
+        assertTlockChainInfoMatchesRuntime(chainInfo, runtime);
+    }
+    const plaintext = await decryptFn(armored, client);
+    return (0, votingCore_1.decodeRbtsVotePlaintext)(plaintext);
+}
+async function createTlockVoteCommit(params, runtime = {}) {
+    const { ciphertext, ciphertextHash, targetRound, drandChainHash } = await createTlockVoteArtifacts(params.isUp, params.predictedUpBps, params.salt, params.epochDurationSeconds, runtime);
+    const commitHash = (0, votingCore_1.buildCommitHash)(params.isUp, params.predictedUpBps, params.salt, params.voter, params.contentId, params.roundId, params.roundReferenceRatingBps, targetRound, drandChainHash, ciphertext);
+    return {
+        ciphertext,
+        ciphertextHash,
+        commitHash,
+        targetRound,
+        drandChainHash,
+        roundReferenceRatingBps: params.roundReferenceRatingBps,
+        commitKey: (0, votingCore_1.buildCommitKey)(params.voter, commitHash),
+    };
+}
+async function createTlockRbtsVoteCommit(params, runtime = {}) {
+    const predictedUpBps = (0, votingCore_1.normalizePredictedUpBps)(params.predictedUpBps);
+    const { ciphertext, ciphertextHash, targetRound, drandChainHash } = await createTlockVoteArtifacts(params.isUp, predictedUpBps, params.salt, params.epochDurationSeconds, runtime);
+    const commitHash = (0, votingCore_1.buildRbtsCommitHash)(params.isUp, predictedUpBps, params.salt, params.voter, params.contentId, params.roundId, params.roundReferenceRatingBps, targetRound, drandChainHash, ciphertext);
+    return {
+        ciphertext,
+        ciphertextHash,
+        commitHash,
+        targetRound,
+        drandChainHash,
+        roundReferenceRatingBps: params.roundReferenceRatingBps,
+        isUp: params.isUp,
+        predictedUpBps,
+        predictedUpPercent: (0, votingCore_1.bpsToPredictionPercent)(predictedUpBps),
+        commitKey: (0, votingCore_1.buildCommitKey)(params.voter, commitHash),
+    };
+}