@rateloop/contracts 0.1.0

package/dist/esm/deployments.d.ts

@@ -0,0 +1,6 @@
+import type { GenericContract } from "./types.js";
+export declare function getSharedDeployment(chainId: number, contractName: string): GenericContract | undefined;
+export declare function getSharedDeploymentAddress(chainId: number, contractName: string): `0x${string}` | undefined;
+export declare function getSharedChainStartBlock(chainId: number): number | undefined;
+export declare function getSharedDeploymentStartBlock(chainId: number, contractName: string): number | undefined;
+//# sourceMappingURL=deployments.d.ts.map

package/dist/esm/deployments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.d.ts","sourceRoot":"","sources":["../../src/deployments.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,SAAS,CAAC;AAQ5E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEtG;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,GAAG,SAAS,CAO3G;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAe5E;AAED,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWvG"}

package/dist/esm/deployments.js

@@ -0,0 +1,39 @@
+import { isAddress } from "viem";
+import deployedContracts from "./deployedContracts.js";
+const sharedDeployments = deployedContracts;
+function isValidStartBlock(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+export function getSharedDeployment(chainId, contractName) {
+    return sharedDeployments[chainId]?.[contractName];
+}
+export function getSharedDeploymentAddress(chainId, contractName) {
+    const address = getSharedDeployment(chainId, contractName)?.address;
+    if (!address || !isAddress(address)) {
+        return undefined;
+    }
+    return address;
+}
+export 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);
+}
+export 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/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./abis/index.js";
+export * from "./deployments.js";
+export { default as deployedContracts } from "./deployedContracts.js";
+export * from "./protocol.js";
+export * from "./types.js";
+export * from "./voting.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export * from "./abis/index.js";
+export * from "./deployments.js";
+export { default as deployedContracts } from "./deployedContracts.js";
+export * from "./protocol.js";
+export * from "./types.js";
+export * from "./voting.js";

package/dist/esm/protocol.d.ts

@@ -0,0 +1,64 @@
+export declare const BPS_SCALE: 10000;
+export declare const USER_PREDICTION_BPS: {
+    readonly min: 100;
+    readonly max: 9900;
+};
+export declare const USER_PREDICTION_PERCENT: {
+    readonly min: number;
+    readonly max: number;
+};
+export declare const ROUND_STATE: {
+    readonly Open: 0;
+    readonly Settled: 1;
+    readonly Cancelled: 2;
+    readonly Tied: 3;
+    readonly RevealFailed: 4;
+};
+export type RoundState = (typeof ROUND_STATE)[keyof typeof ROUND_STATE];
+export declare const ROUND_STATE_LABEL: Record<RoundState, string>;
+export declare const DEFAULT_ROUND_CONFIG: {
+    readonly epochDurationSeconds: number;
+    readonly maxDurationSeconds: number;
+    readonly minVoters: 3;
+    readonly maxVoters: 100;
+};
+export declare const DEFAULT_REVEAL_GRACE_PERIOD_SECONDS: number;
+/** Matches `RoundCleanupLib.REVEAL_FAILED_GRACE_MULTIPLIER` in foundry. */
+export declare const REVEAL_FAILED_GRACE_MULTIPLIER = 24;
+export declare const EPOCH_WEIGHT_BPS: {
+    readonly blind: 10000;
+    readonly informed: 2500;
+};
+export declare const PLATFORM_REWARD_SPLIT_BPS: {
+    readonly frontend: 300;
+};
+export declare const REWARD_SPLIT_BPS: {
+    readonly voter: 9600;
+    readonly submitter: 0;
+    readonly platform: 300;
+    readonly treasury: 100;
+};
+export declare const SCORE_SPREAD_POLICY: {
+    readonly intensityBps: 15000;
+    readonly forfeitMinReveals: 8;
+    readonly maxForfeitBps: 5000;
+};
+export declare const QUESTION_REWARD_PARTICIPANT_FLOORS: {
+    readonly minParticipants: 3;
+    readonly highValueAmount: 1000000000;
+    readonly highValueMinParticipants: 5;
+    readonly veryHighValueAmount: 10000000000;
+    readonly veryHighValueMinParticipants: 8;
+};
+export declare function requiredQuestionRewardParticipants(amountAtomic: bigint | number): number;
+export declare const CONFIDENTIALITY_FLAG_PRIVATE_FOREVER: 1;
+export declare const MIN_NONZERO_CONFIDENTIALITY_BOND = 1000000n;
+export declare const USDC_BY_CHAIN_ID: Record<number, `0x${string}`>;
+export declare const USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID: Record<number, string>;
+export declare function getUsdcEip712DomainName(chainId: number): string;
+export declare const WORLD_ID_V3_ROUTER_BY_CHAIN_ID: Record<number, `0x${string}`>;
+/** @deprecated Use `USDC_BY_CHAIN_ID`; retained while downstream packages migrate names. */
+export declare const WORLD_CHAIN_USDC_BY_CHAIN_ID: Record<number, `0x${string}`>;
+export declare const BOUNTY_ELIGIBILITY_CREDENTIAL_MASK: 14;
+export declare const BOUNTY_ELIGIBILITY_RECENT_RECHECK_FLAG: 128;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/esm/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/protocol.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,EAAG,KAAe,CAAC;AAEzC,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;CAG1B,CAAC;AAEX,eAAO,MAAM,WAAW;;;;;;CAMd,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAMxD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;CAKvB,CAAC;AAEX,eAAO,MAAM,mCAAmC,QAAU,CAAC;AAE3D,2EAA2E;AAC3E,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAEjD,eAAO,MAAM,gBAAgB;;;CAGnB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;CAE5B,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAC;AAEX,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC;AAEX,eAAO,MAAM,kCAAkC;;;;;;CAMrC,CAAC;AAEX,wBAAgB,kCAAkC,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CASxF;AAED,eAAO,MAAM,oCAAoC,EAAG,CAAU,CAAC;AAE/D,eAAO,MAAM,gCAAgC,WAAa,CAAC;AAE3D,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAK1D,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKtE,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAKxE,CAAC;AAEF,4FAA4F;AAC5F,eAAO,MAAM,4BAA4B,+BAAmB,CAAC;AAE7D,eAAO,MAAM,kCAAkC,EAAG,EAAa,CAAC;AAChE,eAAO,MAAM,sCAAsC,EAAG,GAAa,CAAC"}

package/dist/esm/protocol.js

@@ -0,0 +1,94 @@
+export const BPS_SCALE = 10_000;
+export const USER_PREDICTION_BPS = {
+    min: 100,
+    max: 9_900,
+};
+export const USER_PREDICTION_PERCENT = {
+    min: USER_PREDICTION_BPS.min / 100,
+    max: USER_PREDICTION_BPS.max / 100,
+};
+export const ROUND_STATE = {
+    Open: 0,
+    Settled: 1,
+    Cancelled: 2,
+    Tied: 3,
+    RevealFailed: 4,
+};
+export const ROUND_STATE_LABEL = {
+    [ROUND_STATE.Open]: "Open",
+    [ROUND_STATE.Settled]: "Settled",
+    [ROUND_STATE.Cancelled]: "Cancelled",
+    [ROUND_STATE.Tied]: "Tied",
+    [ROUND_STATE.RevealFailed]: "RevealFailed",
+};
+export const DEFAULT_ROUND_CONFIG = {
+    epochDurationSeconds: 20 * 60,
+    maxDurationSeconds: 20 * 60,
+    minVoters: 3,
+    maxVoters: 100,
+};
+export const DEFAULT_REVEAL_GRACE_PERIOD_SECONDS = 60 * 60;
+/** Matches `RoundCleanupLib.REVEAL_FAILED_GRACE_MULTIPLIER` in foundry. */
+export const REVEAL_FAILED_GRACE_MULTIPLIER = 24;
+export const EPOCH_WEIGHT_BPS = {
+    blind: BPS_SCALE,
+    informed: 2_500,
+};
+export const PLATFORM_REWARD_SPLIT_BPS = {
+    frontend: 300,
+};
+export const REWARD_SPLIT_BPS = {
+    voter: 9_600,
+    submitter: 0,
+    platform: PLATFORM_REWARD_SPLIT_BPS.frontend,
+    treasury: 100,
+};
+export const SCORE_SPREAD_POLICY = {
+    intensityBps: 15_000,
+    forfeitMinReveals: 8,
+    maxForfeitBps: 5_000,
+};
+export const QUESTION_REWARD_PARTICIPANT_FLOORS = {
+    minParticipants: 3,
+    highValueAmount: 1_000_000_000,
+    highValueMinParticipants: 5,
+    veryHighValueAmount: 10_000_000_000,
+    veryHighValueMinParticipants: SCORE_SPREAD_POLICY.forfeitMinReveals,
+};
+export function requiredQuestionRewardParticipants(amountAtomic) {
+    const amount = typeof amountAtomic === "bigint" ? amountAtomic : BigInt(amountAtomic);
+    if (amount >= BigInt(QUESTION_REWARD_PARTICIPANT_FLOORS.veryHighValueAmount)) {
+        return QUESTION_REWARD_PARTICIPANT_FLOORS.veryHighValueMinParticipants;
+    }
+    if (amount >= BigInt(QUESTION_REWARD_PARTICIPANT_FLOORS.highValueAmount)) {
+        return QUESTION_REWARD_PARTICIPANT_FLOORS.highValueMinParticipants;
+    }
+    return QUESTION_REWARD_PARTICIPANT_FLOORS.minParticipants;
+}
+export const CONFIDENTIALITY_FLAG_PRIVATE_FOREVER = 1;
+export const MIN_NONZERO_CONFIDENTIALITY_BOND = 1000000n;
+export const USDC_BY_CHAIN_ID = {
+    8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    480: "0x79A02482A880bCE3F13e09Da970dC34db4CD24d1",
+    4801: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+};
+export const USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID = {
+    8453: "USD Coin",
+    84532: "USDC",
+    480: "USDC",
+    4801: "USDC",
+};
+export function getUsdcEip712DomainName(chainId) {
+    return USDC_EIP712_DOMAIN_NAME_BY_CHAIN_ID[chainId] ?? "USDC";
+}
+export const 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. */
+export const WORLD_CHAIN_USDC_BY_CHAIN_ID = USDC_BY_CHAIN_ID;
+export const BOUNTY_ELIGIBILITY_CREDENTIAL_MASK = 0x0e;
+export const BOUNTY_ELIGIBILITY_RECENT_RECHECK_FLAG = 0x80;

package/dist/esm/types.d.ts

@@ -0,0 +1,16 @@
+export type InheritedFunctions = {
+    readonly [key: string]: string;
+};
+export type GenericContract = {
+    address: `0x${string}`;
+    abi: readonly unknown[];
+    inheritedFunctions?: InheritedFunctions;
+    external?: true;
+    deployedOnBlock?: number;
+};
+export type GenericContractsDeclaration = {
+    [chainId: number]: {
+        [contractName: string]: GenericContract;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAEpE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC;IACvB,GAAG,EAAE,SAAS,OAAO,EAAE,CAAC;IACxB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,CAAC,OAAO,EAAE,MAAM,GAAG;QACjB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CAAC;KACzC,CAAC;CACH,CAAC"}

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/voting.d.ts

@@ -0,0 +1,75 @@
+import { type Address } from "viem";
+import { type RbtsCommitHash, type VoteCiphertext, type VoteDrandChainHash, type VoteSalt, type VoteTlockChainInfo } from "./votingCore.js";
+export { MAX_PREDICTED_UP_BPS, MAX_PREDICTED_UP_PERCENT, MIN_PREDICTED_UP_BPS, MIN_PREDICTED_UP_PERCENT, bpsToPredictionPercent, buildCommitHash, buildCommitKey, buildRbtsCommitHash, decodeRbtsVotePlaintext, deriveVoteTlockRevealAvailableAtSeconds, encodeRbtsVotePlaintext, normalizePredictedUpBps, packVoteRoundContext, parseTlockCiphertextMetadata, predictionPercentToBps, unpackVoteRoundContext, type RbtsCommitHash, type TlockCiphertextMetadata, type VoteCiphertext, type VoteCommitHash, type VoteCommitMetadata, type VoteDrandChainHash, type VoteSalt, type VoteTlockChainInfo, } from "./votingCore.js";
+type TlockChainInfo = {
+    period: number;
+    genesis_time: number;
+    hash: string;
+};
+type TlockClient = {
+    chain: () => {
+        info: () => Promise<TlockChainInfo>;
+    };
+};
+type TlockEncryptFn = (targetRound: number, payload: Uint8Array, client: unknown) => Promise<string>;
+type TlockDecryptFn = (ciphertext: string, client: unknown) => Promise<Uint8Array>;
+export type VoteTlockRuntime = {
+    client?: TlockClient;
+    now?: () => number;
+    roundStartTimeSeconds?: bigint | number | null;
+    candidateTimestampOffsetsSeconds?: readonly number[];
+    targetRound?: bigint | number;
+    drandChainHash?: VoteDrandChainHash | null;
+    drandGenesisTimeSeconds?: bigint | number | null;
+    drandPeriodSeconds?: bigint | number | null;
+    encryptFn?: TlockEncryptFn;
+    decryptFn?: TlockDecryptFn;
+};
+export declare function getVoteTlockChainInfo(runtime?: VoteTlockRuntime): Promise<VoteTlockChainInfo>;
+export declare function tlockEncryptVote(isUp: boolean, predictedUpBps: number, salt: VoteSalt, epochDurationSeconds: number, runtime?: VoteTlockRuntime): Promise<VoteCiphertext>;
+export declare function decryptTlockVoteCiphertext(ciphertext: VoteCiphertext, runtime?: VoteTlockRuntime): Promise<{
+    isUp: boolean;
+    predictedUpBps: number;
+    predictedUpPercent: number;
+    salt: VoteSalt;
+} | null>;
+export declare function createTlockVoteCommit(params: {
+    voter: Address;
+    isUp: boolean;
+    predictedUpBps: number;
+    salt: VoteSalt;
+    contentId: bigint;
+    roundId: bigint;
+    roundReferenceRatingBps: number;
+    epochDurationSeconds: number;
+}, runtime?: VoteTlockRuntime): Promise<{
+    ciphertext: VoteCiphertext;
+    ciphertextHash: `0x${string}`;
+    commitHash: `0x${string}`;
+    targetRound: bigint;
+    drandChainHash: VoteDrandChainHash;
+    roundReferenceRatingBps: number;
+    commitKey: `0x${string}`;
+}>;
+export declare function createTlockRbtsVoteCommit(params: {
+    voter: Address;
+    isUp: boolean;
+    predictedUpBps: number;
+    salt: VoteSalt;
+    contentId: bigint;
+    roundId: bigint;
+    roundReferenceRatingBps: number;
+    epochDurationSeconds: number;
+}, runtime?: VoteTlockRuntime): Promise<{
+    ciphertext: VoteCiphertext;
+    ciphertextHash: `0x${string}`;
+    commitHash: RbtsCommitHash;
+    targetRound: bigint;
+    drandChainHash: VoteDrandChainHash;
+    roundReferenceRatingBps: number;
+    isUp: boolean;
+    predictedUpBps: number;
+    predictedUpPercent: number;
+    commitKey: `0x${string}`;
+}>;
+//# sourceMappingURL=voting.d.ts.map

package/dist/esm/voting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voting.d.ts","sourceRoot":"","sources":["../../src/voting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AACzE,OAAO,EAQL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,EACtB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,uBAAuB,EACvB,uCAAuC,EACvC,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,kBAAkB,GACxB,MAAM,cAAc,CAAC;AAEtB,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AASF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM;QACX,IAAI,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;KACrC,CAAC;CACH,CAAC;AAKF,KAAK,cAAc,GAAG,CACpB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,MAAM,CAAC,CAAC;AACrB,KAAK,cAAc,GAAG,CACpB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,UAAU,CAAC,CAAC;AAmBzB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC/C,gCAAgC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrD,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC3C,uBAAuB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACjD,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC5C,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,CAAC;AAwIF,wBAAsB,qBAAqB,CACzC,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAW7B;AAgMD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,OAAO,EACb,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,QAAQ,EACd,oBAAoB,EAAE,MAAM,EAC5B,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,cAAc,CAAC,CASzB;AAED,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,cAAc,EAC1B,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC;IACT,IAAI,EAAE,OAAO,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,QAAQ,CAAC;CAChB,GAAG,IAAI,CAAC,CA8BR;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE;IACN,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,EACD,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC;IACT,UAAU,EAAE,cAAc,CAAC;IAC3B,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,KAAK,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,kBAAkB,CAAC;IACnC,uBAAuB,EAAE,MAAM,CAAC;IAChC,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;CAC1B,CAAC,CA+BD;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE;IACN,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;CAC9B,EACD,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC;IACT,UAAU,EAAE,cAAc,CAAC;IAC3B,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,cAAc,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,kBAAkB,CAAC;IACnC,uBAAuB,EAAE,MAAM,CAAC;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;CAC1B,CAAC,CAmCD"}

package/dist/esm/voting.js

@@ -0,0 +1,279 @@
+import { hexToString, keccak256, stringToHex } from "viem";
+import { bpsToPredictionPercent, buildCommitHash, buildCommitKey, buildRbtsCommitHash, decodeRbtsVotePlaintext, encodeRbtsVotePlaintext, normalizePredictedUpBps, } from "./votingCore.js";
+export { MAX_PREDICTED_UP_BPS, MAX_PREDICTED_UP_PERCENT, MIN_PREDICTED_UP_BPS, MIN_PREDICTED_UP_PERCENT, bpsToPredictionPercent, buildCommitHash, buildCommitKey, buildRbtsCommitHash, decodeRbtsVotePlaintext, deriveVoteTlockRevealAvailableAtSeconds, encodeRbtsVotePlaintext, normalizePredictedUpBps, packVoteRoundContext, parseTlockCiphertextMetadata, predictionPercentToBps, unpackVoteRoundContext, } from "./votingCore.js";
+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 ??= import("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()}.`);
+    }
+}
+export 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, encodeRbtsVotePlaintext(isUp, predictedUpBps, salt), client);
+    const ciphertext = stringToHex(armored);
+    return {
+        ciphertext,
+        ciphertextHash: 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;
+}
+export async function tlockEncryptVote(isUp, predictedUpBps, salt, epochDurationSeconds, runtime = {}) {
+    const { ciphertext } = await createTlockVoteArtifacts(isUp, predictedUpBps, salt, epochDurationSeconds, runtime);
+    return ciphertext;
+}
+export async function decryptTlockVoteCiphertext(ciphertext, runtime = {}) {
+    const tlockModule = await loadTlockModule();
+    const { timelockDecrypt } = tlockModule;
+    const client = resolveTlockClientForRuntime(tlockModule, runtime);
+    const decryptFn = runtime.decryptFn ?? timelockDecrypt;
+    const armored = 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 decodeRbtsVotePlaintext(plaintext);
+}
+export async function createTlockVoteCommit(params, runtime = {}) {
+    const { ciphertext, ciphertextHash, targetRound, drandChainHash } = await createTlockVoteArtifacts(params.isUp, params.predictedUpBps, params.salt, params.epochDurationSeconds, runtime);
+    const commitHash = 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: buildCommitKey(params.voter, commitHash),
+    };
+}
+export async function createTlockRbtsVoteCommit(params, runtime = {}) {
+    const predictedUpBps = normalizePredictedUpBps(params.predictedUpBps);
+    const { ciphertext, ciphertextHash, targetRound, drandChainHash } = await createTlockVoteArtifacts(params.isUp, predictedUpBps, params.salt, params.epochDurationSeconds, runtime);
+    const commitHash = 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: bpsToPredictionPercent(predictedUpBps),
+        commitKey: buildCommitKey(params.voter, commitHash),
+    };
+}