@livo-build/runtime 0.1.0

package/dist/log.js

@@ -0,0 +1,27 @@
+// Structured, consistently-prefixed logging. Plain console under the hood so the
+// keeper run-reporter (which captures console.*) still records everything.
+function emit(level, msg, fields) {
+    const prefix = `[livo:${level}]`;
+    if (fields instanceof Error) {
+        console[level](prefix, msg, fields.stack || fields.message);
+    }
+    else if (fields && Object.keys(fields).length > 0) {
+        let rendered;
+        try {
+            rendered = JSON.stringify(fields);
+        }
+        catch {
+            rendered = String(fields);
+        }
+        console[level](prefix, msg, rendered);
+    }
+    else {
+        console[level](prefix, msg);
+    }
+}
+export const log = {
+    info: (msg, fields) => emit("info", msg, fields),
+    warn: (msg, fields) => emit("warn", msg, fields),
+    error: (msg, err) => emit("error", msg, err),
+    debug: (msg, fields) => emit("debug", msg, fields),
+};

package/dist/retry.d.ts

@@ -0,0 +1,11 @@
+export interface RetryOptions {
+    /** Total attempts (including the first). Default 3. */
+    tries?: number;
+    /** Base delay before the first retry, doubled each round. Default 500ms. */
+    backoffMs?: number;
+    /** Cap on any single backoff. Default 10s. */
+    maxBackoffMs?: number;
+    /** Return false to stop retrying a given error. Default: always retry. */
+    shouldRetry?: (err: unknown, attempt: number) => boolean;
+}
+export declare function retry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,23 @@
+// Retry with exponential backoff — for flaky public RPC endpoints. Worker-safe
+// (uses setTimeout via a Promise; no Node timers).
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function retry(fn, opts = {}) {
+    const tries = opts.tries ?? 3;
+    const base = opts.backoffMs ?? 500;
+    const cap = opts.maxBackoffMs ?? 10_000;
+    let lastErr;
+    for (let attempt = 1; attempt <= tries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt === tries)
+                break;
+            if (opts.shouldRetry && !opts.shouldRetry(err, attempt))
+                break;
+            await sleep(Math.min(cap, base * 2 ** (attempt - 1)));
+        }
+    }
+    throw lastErr;
+}

package/dist/rlp.d.ts

@@ -0,0 +1,4 @@
+import { type Bytes } from "./hex.js";
+export type RlpItem = Bytes | RlpItem[];
+/** RLP-encode a byte string or (possibly nested) list. */
+export declare function rlpEncode(item: RlpItem): Bytes;

package/dist/rlp.js

@@ -0,0 +1,20 @@
+// Minimal RLP encoder — just enough for EIP-1559 (type-2) transaction encoding.
+// Items are byte arrays or nested lists of items. We never decode here.
+import { concatBytes, toMinimalBytes } from "./hex.js";
+function encodeLength(len, offset) {
+    if (len < 56)
+        return new Uint8Array([offset + len]);
+    const lenBytes = toMinimalBytes(BigInt(len));
+    return concatBytes(new Uint8Array([offset + 55 + lenBytes.length]), lenBytes);
+}
+/** RLP-encode a byte string or (possibly nested) list. */
+export function rlpEncode(item) {
+    if (item instanceof Uint8Array) {
+        // Single byte in [0x00, 0x7f] is its own encoding.
+        if (item.length === 1 && item[0] < 0x80)
+            return item;
+        return concatBytes(encodeLength(item.length, 0x80), item);
+    }
+    const payload = concatBytes(...item.map(rlpEncode));
+    return concatBytes(encodeLength(payload.length, 0xc0), payload);
+}

package/dist/store.d.ts

@@ -0,0 +1,31 @@
+export interface D1Like {
+    prepare(query: string): {
+        bind(...values: unknown[]): {
+            first<T = unknown>(colName?: string): Promise<T | null>;
+            run(): Promise<unknown>;
+            all<T = unknown>(): Promise<{
+                results: T[];
+            }>;
+        };
+    };
+    exec?(query: string): Promise<unknown>;
+}
+export declare const STORE_TABLE = "livo_kv";
+export declare class Store {
+    private readonly db;
+    private readonly table;
+    private ready;
+    constructor(db: D1Like, table?: string);
+    /** Lazily create the backing table once per instance. */
+    private init;
+    /** Get a raw string value, or null if absent. */
+    get(key: string): Promise<string | null>;
+    /** Upsert a raw string value. */
+    set(key: string, value: string): Promise<void>;
+    /** Delete a key (no-op if absent). */
+    delete(key: string): Promise<void>;
+    /** Get a JSON-parsed value, or null if absent. */
+    getJSON<T>(key: string): Promise<T | null>;
+    /** Upsert a JSON-serialized value. */
+    setJSON<T>(key: string, value: T): Promise<void>;
+}

package/dist/store.js

@@ -0,0 +1,60 @@
+// Typed key/value persistence over the project's D1 database (bound as env.DB).
+// Replaces the hand-rolled `CREATE TABLE IF NOT EXISTS kv (k,v)` every stateful
+// keeper writes. The table name/shape is stable and documented: callers can rely
+// on `livo_kv(k TEXT PRIMARY KEY, v TEXT, updated_at INTEGER)`.
+export const STORE_TABLE = "livo_kv";
+export class Store {
+    db;
+    table;
+    ready = null;
+    constructor(db, table = STORE_TABLE) {
+        this.db = db;
+        this.table = table;
+        if (!db)
+            throw new Error("Store: no D1 binding — pass env.DB (is the keeper's D1 bound?)");
+    }
+    /** Lazily create the backing table once per instance. */
+    init() {
+        if (!this.ready) {
+            const ddl = `CREATE TABLE IF NOT EXISTS ${this.table} (k TEXT PRIMARY KEY, v TEXT, updated_at INTEGER)`;
+            this.ready = this.db
+                .prepare(ddl)
+                .bind()
+                .run()
+                .then(() => undefined);
+        }
+        return this.ready;
+    }
+    /** Get a raw string value, or null if absent. */
+    async get(key) {
+        await this.init();
+        const row = await this.db
+            .prepare(`SELECT v FROM ${this.table} WHERE k = ?`)
+            .bind(key)
+            .first();
+        return row ? row.v : null;
+    }
+    /** Upsert a raw string value. */
+    async set(key, value) {
+        await this.init();
+        await this.db
+            .prepare(`INSERT INTO ${this.table} (k, v, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(k) DO UPDATE SET v = excluded.v, updated_at = excluded.updated_at`)
+            .bind(key, value, Date.now())
+            .run();
+    }
+    /** Delete a key (no-op if absent). */
+    async delete(key) {
+        await this.init();
+        await this.db.prepare(`DELETE FROM ${this.table} WHERE k = ?`).bind(key).run();
+    }
+    /** Get a JSON-parsed value, or null if absent. */
+    async getJSON(key) {
+        const raw = await this.get(key);
+        return raw === null ? null : JSON.parse(raw);
+    }
+    /** Upsert a JSON-serialized value. */
+    async setJSON(key, value) {
+        await this.set(key, JSON.stringify(value));
+    }
+}

package/dist/tx.d.ts

@@ -0,0 +1,25 @@
+import { type Bytes, type Hex } from "./hex.js";
+export interface Eip1559Tx {
+    chainId: bigint;
+    nonce: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFeePerGas: bigint;
+    gas: bigint;
+    to: Hex | null;
+    value: bigint;
+    data: Hex;
+    accessList?: Array<{
+        address: Hex;
+        storageKeys: Hex[];
+    }>;
+}
+/** The hash a signer signs for an EIP-1559 tx. */
+export declare function transactionHashToSign(tx: Eip1559Tx): Bytes;
+/** Sign an EIP-1559 tx and return the raw 0x-serialized transaction ready to broadcast. */
+export declare function signTransaction(tx: Eip1559Tx, privateKey: string): Hex;
+/** The keccak256 transaction hash of a raw signed tx (what eth_sendRawTransaction returns). */
+export declare function transactionHash(rawTx: Hex): Hex;
+/** EIP-55 checksummed address derived from a private key. */
+export declare function privateKeyToAddress(privateKey: string): Hex;
+/** Apply EIP-55 mixed-case checksum to a 20-byte 0x address. */
+export declare function toChecksumAddress(address: string): Hex;

package/dist/tx.js

@@ -0,0 +1,86 @@
+// EIP-1559 (type-2) transaction encoding + signing. Mirrors viem's
+// signTransaction byte-for-byte (verified in the test suite). secp256k1 signing
+// uses noble with low-S enforced (the canonical form Ethereum requires).
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { rlpEncode } from "./rlp.js";
+import { bytesToHex, concatBytes, hexToBytes, toMinimalBytes, } from "./hex.js";
+/** RLP item for a quantity: minimal big-endian bytes (0 → empty string). */
+function q(value) {
+    return toMinimalBytes(value);
+}
+function addressItem(to) {
+    return to ? hexToBytes(to) : new Uint8Array(0);
+}
+function accessListItems(tx) {
+    return (tx.accessList ?? []).map((entry) => [
+        hexToBytes(entry.address),
+        entry.storageKeys.map((k) => hexToBytes(k)),
+    ]);
+}
+/** The 9-field unsigned payload, prefixed with the 0x02 type byte. */
+function unsignedPayload(tx) {
+    const fields = [
+        q(tx.chainId),
+        q(tx.nonce),
+        q(tx.maxPriorityFeePerGas),
+        q(tx.maxFeePerGas),
+        q(tx.gas),
+        addressItem(tx.to),
+        q(tx.value),
+        hexToBytes(tx.data),
+        accessListItems(tx),
+    ];
+    return concatBytes(new Uint8Array([0x02]), rlpEncode(fields));
+}
+/** The hash a signer signs for an EIP-1559 tx. */
+export function transactionHashToSign(tx) {
+    return keccak_256(unsignedPayload(tx));
+}
+/** Normalize a 0x private key to 32 raw bytes. */
+function normalizeKey(privateKey) {
+    const k = privateKey.trim().replace(/^0x/, "");
+    if (!/^[0-9a-fA-F]{64}$/.test(k))
+        throw new Error("private key must be 32 bytes (64 hex chars)");
+    return hexToBytes(k);
+}
+/** Sign an EIP-1559 tx and return the raw 0x-serialized transaction ready to broadcast. */
+export function signTransaction(tx, privateKey) {
+    const hash = transactionHashToSign(tx);
+    const sig = secp256k1.sign(hash, normalizeKey(privateKey), { lowS: true });
+    const signed = [
+        q(tx.chainId),
+        q(tx.nonce),
+        q(tx.maxPriorityFeePerGas),
+        q(tx.maxFeePerGas),
+        q(tx.gas),
+        addressItem(tx.to),
+        q(tx.value),
+        hexToBytes(tx.data),
+        accessListItems(tx),
+        q(BigInt(sig.recovery)), // yParity
+        q(sig.r),
+        q(sig.s),
+    ];
+    return bytesToHex(concatBytes(new Uint8Array([0x02]), rlpEncode(signed)));
+}
+/** The keccak256 transaction hash of a raw signed tx (what eth_sendRawTransaction returns). */
+export function transactionHash(rawTx) {
+    return bytesToHex(keccak_256(hexToBytes(rawTx)));
+}
+/** EIP-55 checksummed address derived from a private key. */
+export function privateKeyToAddress(privateKey) {
+    const pub = secp256k1.getPublicKey(normalizeKey(privateKey), false).slice(1); // drop 0x04
+    const addr = keccak_256(pub).slice(-20);
+    return toChecksumAddress(bytesToHex(addr));
+}
+/** Apply EIP-55 mixed-case checksum to a 20-byte 0x address. */
+export function toChecksumAddress(address) {
+    const lower = address.toLowerCase().replace(/^0x/, "");
+    const hash = bytesToHex(keccak_256(new TextEncoder().encode(lower))).slice(2);
+    let out = "0x";
+    for (let i = 0; i < lower.length; i++) {
+        out += parseInt(hash[i], 16) >= 8 ? lower[i].toUpperCase() : lower[i];
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@livo-build/runtime",
+  "version": "0.1.0",
+  "description": "Livo runtime — chain signing/reads, D1 state, and logging for keepers, servers, and bots.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./contracts": {
+      "types": "./dist/contracts.d.ts",
+      "import": "./dist/contracts.js"
+    }
+  },
+  "files": ["dist"],
+  "engines": { "node": ">=18" },
+  "keywords": ["livo", "web3", "keeper", "eip1559", "evm"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livo-projects/livo-mcp.git",
+    "directory": "packages/runtime"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.7",
+    "@noble/hashes": "^1.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0",
+    "viem": "^2.52.2"
+  }
+}