@rhinestone/shared-configs 1.4.71 → 1.4.74

package/dist/configs/chains.json

@@ -14,7 +14,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {
@@ -69,7 +70,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {
@@ -121,7 +123,8 @@
             "RELAY"
         ],
         "swapQuoters": [
-            "1inch"
+            "1inch",
+            "velora"
         ],
         "tokens": [
             {
@@ -161,7 +164,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {
@@ -207,7 +211,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {
@@ -282,7 +287,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {
@@ -395,7 +401,8 @@
         ],
         "swapQuoters": [
             "1inch",
-            "0x"
+            "0x",
+            "velora"
         ],
         "tokens": [
             {

package/dist/scripts/sync-abis.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sync-abis.d.ts.map

package/dist/scripts/sync-abis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-abis.d.ts","sourceRoot":"","sources":["../../scripts/sync-abis.ts"],"names":[],"mappings":""}

package/dist/scripts/sync-abis.js

@@ -0,0 +1,435 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function parseArgs(argv) {
+    const opts = {
+        env: "staging",
+        strict: false,
+        generate: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--env" && argv[i + 1]) {
+            opts.env = argv[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--env=")) {
+            opts.env = arg.split("=")[1] ?? opts.env;
+            continue;
+        }
+        if (arg === "--strict") {
+            opts.strict = true;
+            continue;
+        }
+        if (arg === "--generate") {
+            opts.generate = true;
+        }
+    }
+    return opts;
+}
+function readJsonFile(filePath) {
+    return JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8"));
+}
+function normalizeRepo(repo) {
+    let normalized = repo.trim();
+    if (normalized.startsWith("git@github.com:")) {
+        normalized = normalized.replace("git@github.com:", "");
+    }
+    if (normalized.startsWith("https://github.com/")) {
+        normalized = normalized.replace("https://github.com/", "");
+    }
+    if (normalized.endsWith(".git")) {
+        normalized = normalized.slice(0, -4);
+    }
+    return normalized;
+}
+function resolveRef(versionControl, env, repoKey, artifactPath, entry) {
+    if (entry.ref) {
+        return entry.ref;
+    }
+    const envConfig = versionControl[env];
+    if (!envConfig) {
+        throw new Error(`Missing env '${env}' in config/versioncontrol.jsonnet`);
+    }
+    const artifactKey = `${repoKey}/${artifactPath}`;
+    const entryConfig = envConfig[artifactKey] ?? envConfig[repoKey];
+    if (!entryConfig) {
+        throw new Error(`Missing versioncontrol entry for ${artifactKey} (env=${env})`);
+    }
+    if (typeof entryConfig === "string") {
+        return entryConfig;
+    }
+    if (entryConfig.ref) {
+        return entryConfig.ref;
+    }
+    throw new Error(`No ref found for ${artifactKey} (env=${env})`);
+}
+function loadVersionControl(yeetRoot) {
+    const jsonnetFile = node_path_1.default.join(yeetRoot, "config", "versioncontrol.jsonnet");
+    const jsonnetEth = node_path_1.default.join(yeetRoot, "bin", "jsonnet-eth");
+    let output = "";
+    if ((0, node_fs_1.existsSync)(jsonnetEth)) {
+        output = (0, node_child_process_1.execFileSync)(jsonnetEth, [jsonnetFile], {
+            cwd: yeetRoot,
+            encoding: "utf8",
+        });
+    }
+    else {
+        output = (0, node_child_process_1.execFileSync)("go", ["run", "./cmd/jsonnet-eth", jsonnetFile], {
+            cwd: yeetRoot,
+            encoding: "utf8",
+        });
+    }
+    return JSON.parse(output);
+}
+function fetchArtifactJson(repoKey, ref, artifactPath, fileName) {
+    const fullPath = node_path_1.default.posix.join(artifactPath, fileName);
+    const ghArgs = [
+        "api",
+        `repos/${repoKey}/contents/${fullPath}?ref=${ref}`,
+        "--jq",
+        ".content",
+    ];
+    const content = (0, node_child_process_1.execFileSync)("gh", ghArgs, { encoding: "utf8" }).trim();
+    if (!content) {
+        throw new Error(`Empty response for ${repoKey}:${fullPath}@${ref}`);
+    }
+    const decoded = Buffer.from(content.replace(/\n/g, ""), "base64").toString("utf8");
+    return JSON.parse(decoded);
+}
+function fetchRepoFile(repoKey, ref, filePath) {
+    const fullPath = node_path_1.default.posix.normalize(filePath);
+    const ghArgs = [
+        "api",
+        `repos/${repoKey}/contents/${fullPath}?ref=${ref}`,
+        "--jq",
+        ".content",
+    ];
+    const content = (0, node_child_process_1.execFileSync)("gh", ghArgs, { encoding: "utf8" }).trim();
+    if (!content) {
+        throw new Error(`Empty response for ${repoKey}:${fullPath}@${ref}`);
+    }
+    return Buffer.from(content.replace(/\n/g, ""), "base64").toString("utf8");
+}
+function extractAbi(payload) {
+    if (Array.isArray(payload)) {
+        return payload;
+    }
+    if (payload && typeof payload === "object" && "abi" in payload) {
+        const abi = payload.abi;
+        if (Array.isArray(abi)) {
+            return abi;
+        }
+    }
+    throw new Error("Unsupported artifact format: expected ABI array or { abi }");
+}
+function filterAbiByFunctions(abi, functions) {
+    const allowed = new Set(functions);
+    const found = new Set();
+    const filtered = abi.filter((item) => {
+        if (!item || typeof item !== "object") {
+            return false;
+        }
+        const typed = item;
+        if (typed.type !== "function" || !typed.name) {
+            return false;
+        }
+        if (!allowed.has(typed.name)) {
+            return false;
+        }
+        found.add(typed.name);
+        return true;
+    });
+    const missing = functions.filter((name) => !found.has(name));
+    if (missing.length > 0) {
+        throw new Error(`Missing functions in ABI: ${missing.join(", ")}`);
+    }
+    return filtered;
+}
+function stripComments(source) {
+    const withoutBlock = source.replace(/\/\*[\s\S]*?\*\//g, "");
+    return withoutBlock.replace(/\/\/.*$/gm, "");
+}
+function parseStruct(source, structName) {
+    const cleaned = stripComments(source);
+    const structRegex = new RegExp(`struct\\s+${structName}\\s*\\{([\\s\\S]*?)\\}`);
+    const match = cleaned.match(structRegex);
+    if (!match) {
+        throw new Error(`Struct ${structName} not found`);
+    }
+    const body = match[1];
+    const fields = body
+        .split(";")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const components = [];
+    for (const field of fields) {
+        const tokens = field.split(/\s+/).filter(Boolean);
+        if (tokens.length < 2) {
+            continue;
+        }
+        const name = tokens[tokens.length - 1];
+        const type = tokens.slice(0, -1).join(" ");
+        components.push({
+            name,
+            type,
+            internalType: type,
+        });
+    }
+    return components;
+}
+function resolveParamType(typeStr, structs) {
+    const arrayMatch = typeStr.match(/^(.+?)(\[[^\]]*\])+$/);
+    const baseType = arrayMatch ? arrayMatch[1] : typeStr;
+    const arraySuffix = arrayMatch ? typeStr.slice(baseType.length) : "";
+    if (structs[baseType]) {
+        return {
+            type: `tuple${arraySuffix}`,
+            internalType: `struct ${baseType}${arraySuffix}`,
+            components: structs[baseType],
+        };
+    }
+    return {
+        type: typeStr,
+        internalType: typeStr,
+    };
+}
+function parseParams(paramsText, structs) {
+    const trimmed = paramsText.trim();
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const tokens = part
+            .split(/\s+/)
+            .filter((token) => token &&
+            token !== "calldata" &&
+            token !== "memory" &&
+            token !== "storage");
+        const name = tokens.length > 1 ? tokens[tokens.length - 1] : "";
+        const type = tokens.length > 1 ? tokens.slice(0, -1).join(" ") : tokens[0];
+        const resolved = resolveParamType(type, structs);
+        return {
+            name,
+            ...resolved,
+        };
+    });
+}
+function parseInterfaceAbi(source, interfaceName, structs) {
+    const cleaned = stripComments(source);
+    const interfaceIndex = cleaned.indexOf(`interface ${interfaceName}`);
+    if (interfaceIndex === -1) {
+        throw new Error(`Interface ${interfaceName} not found`);
+    }
+    const braceStart = cleaned.indexOf("{", interfaceIndex);
+    if (braceStart === -1) {
+        throw new Error(`Interface ${interfaceName} has no body`);
+    }
+    let depth = 0;
+    let end = -1;
+    for (let i = braceStart; i < cleaned.length; i += 1) {
+        const char = cleaned[i];
+        if (char === "{") {
+            depth += 1;
+        }
+        else if (char === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                end = i;
+                break;
+            }
+        }
+    }
+    if (end === -1) {
+        throw new Error(`Interface ${interfaceName} body not closed`);
+    }
+    const body = cleaned.slice(braceStart + 1, end).replace(/\s+/g, " ");
+    const functions = [];
+    const regex = /function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)\s*external\s*(?:returns\s*\(([^)]*)\))?\s*;/g;
+    let match;
+    while ((match = regex.exec(body)) !== null) {
+        const name = match[1];
+        const inputsText = match[2] ?? "";
+        const outputsText = match[3] ?? "";
+        functions.push({
+            type: "function",
+            name,
+            inputs: parseParams(inputsText, structs),
+            outputs: parseParams(outputsText, structs),
+            stateMutability: "nonpayable",
+        });
+    }
+    if (functions.length === 0) {
+        throw new Error(`No functions parsed for ${interfaceName}`);
+    }
+    return functions;
+}
+function abiParamKey(param) {
+    if (!param || typeof param !== "object") {
+        return "";
+    }
+    const typed = param;
+    if (!typed.type) {
+        return "";
+    }
+    if (typed.type.startsWith("tuple") && Array.isArray(typed.components)) {
+        const inner = typed.components.map(abiParamKey).join(",");
+        return `${typed.type}(${inner})`;
+    }
+    return typed.type;
+}
+function abiItemKey(item) {
+    if (!item || typeof item !== "object") {
+        return "";
+    }
+    const typed = item;
+    const type = typed.type ?? "";
+    const name = typed.name ?? "";
+    const inputs = Array.isArray(typed.inputs)
+        ? typed.inputs.map(abiParamKey).join(",")
+        : "";
+    const outputs = Array.isArray(typed.outputs)
+        ? typed.outputs.map(abiParamKey).join(",")
+        : "";
+    const mutability = typed.stateMutability ?? "";
+    const anonymous = typed.anonymous ? "1" : "0";
+    return `${type}|${name}|${inputs}|${outputs}|${mutability}|${anonymous}`;
+}
+function mergeAbis(abis) {
+    const merged = [];
+    const seen = new Set();
+    let hasConstructor = false;
+    let hasFallback = false;
+    let hasReceive = false;
+    for (const abi of abis) {
+        for (const item of abi) {
+            if (!item || typeof item !== "object") {
+                merged.push(item);
+                continue;
+            }
+            const typed = item;
+            const type = typed.type ?? "";
+            if (type === "constructor") {
+                if (hasConstructor) {
+                    continue;
+                }
+                hasConstructor = true;
+            }
+            else if (type === "fallback") {
+                if (hasFallback) {
+                    continue;
+                }
+                hasFallback = true;
+            }
+            else if (type === "receive") {
+                if (hasReceive) {
+                    continue;
+                }
+                hasReceive = true;
+            }
+            const key = abiItemKey(item);
+            if (key) {
+                if (seen.has(key)) {
+                    continue;
+                }
+                seen.add(key);
+            }
+            merged.push(item);
+        }
+    }
+    return merged;
+}
+function resolveEntryAbi(entry, versionControl, opts) {
+    if (entry.solFile && entry.interface) {
+        if (!entry.repo) {
+            throw new Error("missing repo for interface source");
+        }
+        const repoKey = normalizeRepo(entry.repo);
+        const ref = resolveRef(versionControl, opts.env, repoKey, entry.solFile, entry);
+        const interfaceSource = fetchRepoFile(repoKey, ref, entry.solFile);
+        const structs = {};
+        if (entry.structs) {
+            for (const [alias, spec] of Object.entries(entry.structs)) {
+                const structSource = fetchRepoFile(repoKey, ref, spec.solFile);
+                structs[alias] = parseStruct(structSource, spec.struct);
+            }
+        }
+        return parseInterfaceAbi(interfaceSource, entry.interface, structs);
+    }
+    if (!entry.repo || !entry.path) {
+        throw new Error("missing repo/path");
+    }
+    let payload;
+    if (entry.localFile && (0, node_fs_1.existsSync)(entry.localFile)) {
+        payload = readJsonFile(entry.localFile);
+    }
+    else {
+        const repoKey = normalizeRepo(entry.repo);
+        const ref = resolveRef(versionControl, opts.env, repoKey, entry.path, entry);
+        const artifactName = node_path_1.default.posix.basename(entry.path);
+        const fileName = entry.file ?? `${artifactName}.json`;
+        payload = fetchArtifactJson(repoKey, ref, entry.path, fileName);
+    }
+    let abi = extractAbi(payload);
+    if (entry.functions && entry.functions.length > 0) {
+        abi = filterAbiByFunctions(abi, entry.functions);
+    }
+    return abi;
+}
+function syncAbis() {
+    const opts = parseArgs(process.argv.slice(2));
+    const sharedConfigsRoot = process.cwd();
+    const yeetRoot = node_path_1.default.resolve(sharedConfigsRoot, "..");
+    const sourcesPath = node_path_1.default.join(sharedConfigsRoot, "abis-source", "sources.json");
+    const sources = readJsonFile(sourcesPath);
+    const versionControl = loadVersionControl(yeetRoot);
+    const outputDir = node_path_1.default.join(sharedConfigsRoot, "abis-source");
+    if (!(0, node_fs_1.existsSync)(outputDir)) {
+        (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    }
+    const failures = [];
+    for (const [targetFile, entry] of Object.entries(sources)) {
+        if (entry.skip) {
+            continue;
+        }
+        try {
+            const abi = entry.merge && entry.merge.length > 0
+                ? mergeAbis(entry.merge.map((child) => resolveEntryAbi(child, versionControl, opts)))
+                : resolveEntryAbi(entry, versionControl, opts);
+            const outputPath = node_path_1.default.join(outputDir, targetFile);
+            (0, node_fs_1.writeFileSync)(outputPath, `${JSON.stringify(abi, null, 2)}\n`);
+            console.log(`Updated ${targetFile}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            const line = `${targetFile}: ${message}`;
+            if (opts.strict) {
+                throw new Error(line);
+            }
+            failures.push(line);
+        }
+    }
+    if (failures.length > 0) {
+        console.warn("ABI sync warnings:");
+        for (const line of failures) {
+            console.warn(`- ${line}`);
+        }
+    }
+    if (opts.generate) {
+        (0, node_child_process_1.execFileSync)("bun", ["run", "generate:abis"], {
+            cwd: sharedConfigsRoot,
+            stdio: "inherit",
+        });
+    }
+}
+syncAbis();