@rateloop/contracts 0.1.0

package/dist/esm/votingCore.d.ts

@@ -0,0 +1,55 @@
+import { type Address } from "viem";
+export type VoteSalt = `0x${string}`;
+export type VoteCiphertext = `0x${string}`;
+export type VoteCommitHash = `0x${string}`;
+export type VoteDrandChainHash = `0x${string}`;
+export type RbtsCommitHash = VoteCommitHash;
+export interface VoteCommitMetadata {
+    targetRound: bigint;
+    drandChainHash: VoteDrandChainHash;
+}
+export interface TlockCiphertextMetadata extends VoteCommitMetadata {
+}
+export interface VoteTlockChainInfo {
+    periodSeconds: bigint;
+    genesisTimeSeconds: bigint;
+    drandChainHash: VoteDrandChainHash;
+}
+export declare const MIN_PREDICTED_UP_BPS: 100;
+export declare const MAX_PREDICTED_UP_BPS: 9900;
+export declare const MIN_PREDICTED_UP_PERCENT: number;
+export declare const MAX_PREDICTED_UP_PERCENT: number;
+export declare function normalizePredictedUpBps(predictedUpBps: number): number;
+export declare function predictionPercentToBps(predictedUpPercent: number): number;
+export declare function bpsToPredictionPercent(predictedUpBps: number): number;
+export declare function packVoteRoundContext(roundId: bigint, roundReferenceRatingBps: number): bigint;
+export declare function unpackVoteRoundContext(roundContext: bigint): {
+    roundId: bigint;
+    roundReferenceRatingBps: number;
+};
+/**
+ * C-3 (2026-05-22 audit): the formula here uses (targetRound - 1) * period because the
+ * local convention (see voting.ts's computeTargetRoundForBeaconTime lineage) treats round
+ * 1 as occurring at the genesis time itself. The drand network's own signature-publishing
+ * schedule produces round R at `genesis + R * period`, so callers may see "reveal
+ * available" up to one period before drand has actually published the round's signature;
+ * this is currently absorbed as a brief retry at the call site.
+ *
+ * If a follow-up confirms drand's schedule should govern the displayed availability
+ * (rather than the local round numbering), change to `targetRound * periodSeconds` and
+ * update the boundary tests in voting.test.ts in lockstep. Do not change one without
+ * the other.
+ */
+export declare function deriveVoteTlockRevealAvailableAtSeconds(targetRound: bigint, chainInfo: VoteTlockChainInfo): bigint;
+export declare function encodeRbtsVotePlaintext(isUp: boolean, predictedUpBps: number, salt: VoteSalt): Uint8Array;
+export declare function decodeRbtsVotePlaintext(plaintext: Uint8Array): {
+    isUp: boolean;
+    predictedUpBps: number;
+    predictedUpPercent: number;
+    salt: VoteSalt;
+} | null;
+export declare function buildCommitHash(isUp: boolean, predictedUpBps: number, salt: VoteSalt, voter: Address, contentId: bigint, roundId: bigint, roundReferenceRatingBps: number, targetRound: bigint, drandChainHash: VoteDrandChainHash, ciphertext: VoteCiphertext): VoteCommitHash;
+export declare function buildRbtsCommitHash(isUp: boolean, predictedUpBps: number, salt: VoteSalt, voter: Address, contentId: bigint, roundId: bigint, roundReferenceRatingBps: number, targetRound: bigint, drandChainHash: VoteDrandChainHash, ciphertext: VoteCiphertext): RbtsCommitHash;
+export declare function buildCommitKey(voter: Address, commitHash: `0x${string}`): `0x${string}`;
+export declare function parseTlockCiphertextMetadata(ciphertext: VoteCiphertext): TlockCiphertextMetadata | null;
+//# sourceMappingURL=votingCore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"votingCore.d.ts","sourceRoot":"","sources":["../../src/votingCore.ts"],"names":[],"mappings":"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"}

package/dist/esm/votingCore.js

@@ -0,0 +1,286 @@
+import { encodePacked, hexToString, keccak256 } from "viem";
+import { USER_PREDICTION_BPS, USER_PREDICTION_PERCENT } from "./protocol.js";
+const AGE_ARMOR_HEADER = "-----BEGIN AGE ENCRYPTED FILE-----";
+const AGE_ARMOR_FOOTER = "-----END AGE ENCRYPTED FILE-----";
+const AGE_ARMOR_LINE_CHUNK_SIZE = 64;
+const AGE_VERSION_LINE = "age-encryption.org/v1";
+const AGE_RECIPIENT_PREFIX = "-> ";
+const AGE_MAC_PREFIX = "--- ";
+const TLOCK_STANZA_PREFIX = "-> tlock ";
+const UNPADDED_BASE64_LINE = /^[A-Za-z0-9+/]+$/;
+const AGE_MAC_LENGTH = 32;
+const MIN_TLOCK_STANZA_BODY_LENGTH = 80;
+const MIN_ENCRYPTED_BODY_LENGTH = 65;
+const ROUND_REFERENCE_RATING_MASK = 0xffffn;
+const RBTS_PLAINTEXT_VERSION = 2;
+export const MIN_PREDICTED_UP_BPS = USER_PREDICTION_BPS.min;
+export const MAX_PREDICTED_UP_BPS = USER_PREDICTION_BPS.max;
+export const MIN_PREDICTED_UP_PERCENT = USER_PREDICTION_PERCENT.min;
+export const MAX_PREDICTED_UP_PERCENT = USER_PREDICTION_PERCENT.max;
+export function normalizePredictedUpBps(predictedUpBps) {
+    if (!Number.isInteger(predictedUpBps) ||
+        predictedUpBps < MIN_PREDICTED_UP_BPS ||
+        predictedUpBps > MAX_PREDICTED_UP_BPS) {
+        throw new Error("predictedUpBps must be an integer from 100 to 9900");
+    }
+    return predictedUpBps;
+}
+export function predictionPercentToBps(predictedUpPercent) {
+    if (!Number.isFinite(predictedUpPercent) ||
+        predictedUpPercent < MIN_PREDICTED_UP_PERCENT ||
+        predictedUpPercent > MAX_PREDICTED_UP_PERCENT) {
+        throw new Error("predicted up percentage must be from 1 to 99");
+    }
+    return normalizePredictedUpBps(Math.round(predictedUpPercent * 100));
+}
+export function bpsToPredictionPercent(predictedUpBps) {
+    return normalizePredictedUpBps(predictedUpBps) / 100;
+}
+export function packVoteRoundContext(roundId, roundReferenceRatingBps) {
+    if (roundId <= 0n) {
+        throw new Error("roundId must be positive");
+    }
+    if (!Number.isInteger(roundReferenceRatingBps) ||
+        roundReferenceRatingBps < 0 ||
+        roundReferenceRatingBps > 65_535) {
+        throw new Error("roundReferenceRatingBps must fit uint16");
+    }
+    return (roundId << 16n) | BigInt(roundReferenceRatingBps);
+}
+export function unpackVoteRoundContext(roundContext) {
+    return {
+        roundId: roundContext >> 16n,
+        roundReferenceRatingBps: Number(roundContext & ROUND_REFERENCE_RATING_MASK),
+    };
+}
+/**
+ * C-3 (2026-05-22 audit): the formula here uses (targetRound - 1) * period because the
+ * local convention (see voting.ts's computeTargetRoundForBeaconTime lineage) treats round
+ * 1 as occurring at the genesis time itself. The drand network's own signature-publishing
+ * schedule produces round R at `genesis + R * period`, so callers may see "reveal
+ * available" up to one period before drand has actually published the round's signature;
+ * this is currently absorbed as a brief retry at the call site.
+ *
+ * If a follow-up confirms drand's schedule should govern the displayed availability
+ * (rather than the local round numbering), change to `targetRound * periodSeconds` and
+ * update the boundary tests in voting.test.ts in lockstep. Do not change one without
+ * the other.
+ */
+export function deriveVoteTlockRevealAvailableAtSeconds(targetRound, chainInfo) {
+    if (targetRound <= 0n || chainInfo.periodSeconds <= 0n) {
+        return 0n;
+    }
+    return (chainInfo.genesisTimeSeconds + (targetRound - 1n) * chainInfo.periodSeconds);
+}
+function saltToBytes(salt) {
+    const hex = salt.startsWith("0x") ? salt.slice(2) : salt;
+    if (hex.length !== 64)
+        throw new Error("salt must be 32 bytes");
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+        bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return `0x${Array.from(bytes)
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("")}`;
+}
+export function encodeRbtsVotePlaintext(isUp, predictedUpBps, salt) {
+    const normalizedPrediction = normalizePredictedUpBps(predictedUpBps);
+    const plaintext = new Uint8Array(36);
+    plaintext[0] = RBTS_PLAINTEXT_VERSION;
+    plaintext[1] = isUp ? 1 : 0;
+    plaintext[2] = normalizedPrediction >> 8;
+    plaintext[3] = normalizedPrediction & 0xff;
+    plaintext.set(saltToBytes(salt), 4);
+    return plaintext;
+}
+export function decodeRbtsVotePlaintext(plaintext) {
+    if (plaintext.length !== 36 || plaintext[0] !== RBTS_PLAINTEXT_VERSION)
+        return null;
+    if (plaintext[1] !== 0 && plaintext[1] !== 1)
+        return null;
+    const predictedUpBps = (plaintext[2] << 8) | plaintext[3];
+    if (predictedUpBps < MIN_PREDICTED_UP_BPS ||
+        predictedUpBps > MAX_PREDICTED_UP_BPS)
+        return null;
+    return {
+        isUp: plaintext[1] === 1,
+        predictedUpBps,
+        predictedUpPercent: bpsToPredictionPercent(predictedUpBps),
+        salt: bytesToHex(plaintext.slice(4, 36)),
+    };
+}
+export function buildCommitHash(isUp, predictedUpBps, salt, voter, contentId, roundId, roundReferenceRatingBps, targetRound, drandChainHash, ciphertext) {
+    const ciphertextHash = keccak256(ciphertext);
+    return keccak256(encodePacked([
+        "bool",
+        "uint16",
+        "bytes32",
+        "address",
+        "uint256",
+        "uint256",
+        "uint16",
+        "uint64",
+        "bytes32",
+        "bytes32",
+    ], [
+        isUp,
+        normalizePredictedUpBps(predictedUpBps),
+        salt,
+        voter,
+        contentId,
+        roundId,
+        roundReferenceRatingBps,
+        targetRound,
+        drandChainHash,
+        ciphertextHash,
+    ]));
+}
+export function buildRbtsCommitHash(isUp, predictedUpBps, salt, voter, contentId, roundId, roundReferenceRatingBps, targetRound, drandChainHash, ciphertext) {
+    return buildCommitHash(isUp, predictedUpBps, salt, voter, contentId, roundId, roundReferenceRatingBps, targetRound, drandChainHash, ciphertext);
+}
+export function buildCommitKey(voter, commitHash) {
+    return keccak256(encodePacked(["address", "bytes32"], [voter, commitHash]));
+}
+function decodeBase64Bytes(value) {
+    if (typeof globalThis.atob !== "function") {
+        return null;
+    }
+    try {
+        const binary = globalThis.atob(value);
+        const bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index++) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        return bytes;
+    }
+    catch {
+        return null;
+    }
+}
+function asciiBytesToString(bytes, start, end) {
+    let value = "";
+    for (let index = start; index < end; index++) {
+        value += String.fromCharCode(bytes[index]);
+    }
+    return value;
+}
+function decodeAgeArmor(armored) {
+    const trimmed = armored.trim();
+    if (!trimmed.startsWith(AGE_ARMOR_HEADER) ||
+        !trimmed.endsWith(AGE_ARMOR_FOOTER)) {
+        return null;
+    }
+    const payload = trimmed.slice(AGE_ARMOR_HEADER.length, trimmed.length - AGE_ARMOR_FOOTER.length);
+    const lines = payload.split(/\r?\n/);
+    if (lines.some((line) => line.length > AGE_ARMOR_LINE_CHUNK_SIZE)) {
+        return null;
+    }
+    if (lines.some((line) => line.length > 0 && !/^[A-Za-z0-9+/=]+$/.test(line))) {
+        return null;
+    }
+    const lastLine = lines.at(-1) ?? "";
+    if (lastLine.length > AGE_ARMOR_LINE_CHUNK_SIZE) {
+        return null;
+    }
+    return decodeBase64Bytes(lines.join(""));
+}
+function readAsciiLine(payload, cursor) {
+    if (cursor >= payload.length)
+        return null;
+    let end = cursor;
+    while (end < payload.length &&
+        payload[end] !== 0x0a &&
+        payload[end] !== 0x0d) {
+        end++;
+    }
+    if (end >= payload.length) {
+        return null;
+    }
+    let nextCursor = end + 1;
+    if (payload[end] === 0x0d &&
+        nextCursor < payload.length &&
+        payload[nextCursor] === 0x0a) {
+        nextCursor++;
+    }
+    return {
+        line: asciiBytesToString(payload, cursor, end),
+        nextCursor,
+    };
+}
+function isValidUnpaddedBase64Line(line) {
+    return (line.length > 0 &&
+        line.length <= AGE_ARMOR_LINE_CHUNK_SIZE &&
+        UNPADDED_BASE64_LINE.test(line));
+}
+function unpaddedBase64DecodedLength(charLength) {
+    const remainder = charLength % 4;
+    if (remainder === 1)
+        return null;
+    return Math.floor(charLength / 4) * 3 + (remainder === 0 ? 0 : remainder - 1);
+}
+export function parseTlockCiphertextMetadata(ciphertext) {
+    try {
+        const armored = hexToString(ciphertext);
+        const agePayload = decodeAgeArmor(armored);
+        if (!agePayload)
+            return null;
+        const versionLine = readAsciiLine(agePayload, 0);
+        if (!versionLine || versionLine.line !== AGE_VERSION_LINE) {
+            return null;
+        }
+        const stanzaLine = readAsciiLine(agePayload, versionLine.nextCursor);
+        if (!stanzaLine || !stanzaLine.line.startsWith(TLOCK_STANZA_PREFIX)) {
+            return null;
+        }
+        const recipientMatch = /^-> tlock ([0-9]+) ([0-9a-fA-F]{64})$/.exec(stanzaLine.line);
+        if (!recipientMatch) {
+            return null;
+        }
+        let cursor = stanzaLine.nextCursor;
+        let stanzaBodyCharLength = 0;
+        while (cursor < agePayload.length) {
+            const bodyLine = readAsciiLine(agePayload, cursor);
+            if (!bodyLine)
+                return null;
+            if (bodyLine.line.startsWith(AGE_MAC_PREFIX)) {
+                break;
+            }
+            if (bodyLine.line.startsWith(AGE_RECIPIENT_PREFIX) ||
+                !isValidUnpaddedBase64Line(bodyLine.line)) {
+                return null;
+            }
+            stanzaBodyCharLength += bodyLine.line.length;
+            cursor = bodyLine.nextCursor;
+        }
+        const decodedStanzaBodyLength = unpaddedBase64DecodedLength(stanzaBodyCharLength);
+        if (decodedStanzaBodyLength == null ||
+            decodedStanzaBodyLength < MIN_TLOCK_STANZA_BODY_LENGTH) {
+            return null;
+        }
+        const macLine = readAsciiLine(agePayload, cursor);
+        if (!macLine || !macLine.line.startsWith(AGE_MAC_PREFIX)) {
+            return null;
+        }
+        const mac = macLine.line.slice(AGE_MAC_PREFIX.length);
+        const decodedMacLength = unpaddedBase64DecodedLength(mac.length);
+        if (!isValidUnpaddedBase64Line(mac) ||
+            decodedMacLength !== AGE_MAC_LENGTH) {
+            return null;
+        }
+        if (agePayload.length - macLine.nextCursor < MIN_ENCRYPTED_BODY_LENGTH) {
+            return null;
+        }
+        const [, roundStr, chainHash] = recipientMatch;
+        return {
+            targetRound: BigInt(roundStr),
+            drandChainHash: `0x${chainHash.toLowerCase()}`,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@rateloop/contracts",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Generated ABIs, deployment metadata, and protocol constants for RateLoop integrations",
+  "homepage": "https://github.com/Noc2/RateLoop/tree/main/packages/contracts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Noc2/RateLoop.git",
+    "directory": "packages/contracts"
+  },
+  "bugs": {
+    "url": "https://github.com/Noc2/RateLoop/issues"
+  },
+  "keywords": [
+    "rateloop",
+    "contracts",
+    "abis",
+    "deployments",
+    "viem"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "abis": [
+        "dist/esm/abis/index.d.ts"
+      ],
+      "deployments": [
+        "dist/esm/deployments.d.ts"
+      ],
+      "deployedContracts": [
+        "dist/esm/deployedContracts.d.ts"
+      ],
+      "protocol": [
+        "dist/esm/protocol.d.ts"
+      ],
+      "types": [
+        "dist/esm/types.d.ts"
+      ],
+      "voting": [
+        "dist/esm/voting.d.ts"
+      ],
+      "votingCore": [
+        "dist/esm/votingCore.d.ts"
+      ],
+      "*": [
+        "dist/esm/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./abis": {
+      "types": "./dist/esm/abis/index.d.ts",
+      "import": "./dist/esm/abis/index.js",
+      "require": "./dist/cjs/abis/index.js"
+    },
+    "./deployments": {
+      "types": "./dist/esm/deployments.d.ts",
+      "import": "./dist/esm/deployments.js",
+      "require": "./dist/cjs/deployments.js"
+    },
+    "./deployedContracts": {
+      "types": "./dist/esm/deployedContracts.d.ts",
+      "import": "./dist/esm/deployedContracts.js",
+      "require": "./dist/cjs/deployedContracts.js"
+    },
+    "./protocol": {
+      "types": "./dist/esm/protocol.d.ts",
+      "import": "./dist/esm/protocol.js",
+      "require": "./dist/cjs/protocol.js"
+    },
+    "./types": {
+      "types": "./dist/esm/types.d.ts",
+      "import": "./dist/esm/types.js",
+      "require": "./dist/cjs/types.js"
+    },
+    "./voting": {
+      "types": "./dist/esm/voting.d.ts",
+      "import": "./dist/esm/voting.js",
+      "require": "./dist/cjs/voting.js"
+    },
+    "./votingCore": {
+      "types": "./dist/esm/votingCore.d.ts",
+      "import": "./dist/esm/votingCore.js",
+      "require": "./dist/cjs/votingCore.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/with-workspace-dist-lock.mjs \"node ../../scripts/clean-package-dist.mjs && tsc -p tsconfig.json && node ../../scripts/fix-esm-extensions.mjs dist/esm && tsc -p tsconfig.cjs.json && node ../../scripts/write-cjs-package-json.mjs dist/cjs\"",
+    "prepack": "yarn build",
+    "test": "node ../../scripts/run-node-tests.mjs src",
+    "check-types": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "tlock-js": "^0.9.0",
+    "viem": "2.39.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.8.2"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=24 <25"
+  }
+}