@logrix/sdk 0.3.0

package/dist/commands/init.js

@@ -0,0 +1,200 @@
+"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.initCommand = initCommand;
+const commander_1 = require("commander");
+const prompts_1 = require("@inquirer/prompts");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const templates_1 = require("../templates");
+const NETWORKS = {
+    "ethereum": { name: "ethereum", chainId: 1, rpcUrl: "https://eth.llamarpc.com" },
+    "arbitrum-one": { name: "arbitrum-one", chainId: 42161, rpcUrl: "https://arb1.arbitrum.io/rpc" },
+    "base": { name: "base", chainId: 8453, rpcUrl: "https://mainnet.base.org" },
+    "polygon": { name: "polygon", chainId: 137, rpcUrl: "https://polygon-rpc.com" },
+    "arbitrum-sepolia": { name: "arbitrum-sepolia", chainId: 421614, rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc" },
+    "sepolia": { name: "sepolia", chainId: 11155111, rpcUrl: "https://rpc.sepolia.org" },
+};
+function initCommand() {
+    const cmd = new commander_1.Command("init");
+    cmd
+        .description("Scaffold a new Logrix indexer project")
+        .argument("[name]", "Project directory name")
+        .option("-y, --yes", "Skip prompts and use defaults (non-interactive)")
+        .option("--network <network>", "Network preset name (e.g. arbitrum-one, ethereum, base)")
+        .option("--rpc <url>", "Custom RPC endpoint URL")
+        .option("--contract-name <name>", "Contract name")
+        .option("--address <address>", "Contract target address")
+        .option("--start-block <block>", "Starting block number")
+        .action(async (nameArg, opts) => {
+        console.log("\nLogrix Project Initializer\n");
+        const isNonInteractive = opts.yes || !process.stdin.isTTY;
+        // Project Name
+        let projectName = nameArg || opts.name;
+        if (!projectName) {
+            if (isNonInteractive) {
+                projectName = "my-indexer";
+            }
+            else {
+                projectName = await (0, prompts_1.input)({
+                    message: "Project name:",
+                    default: "my-indexer",
+                    validate: (v) => v.trim().length > 0 || "Name cannot be empty",
+                });
+            }
+        }
+        projectName = projectName.trim();
+        const targetDir = path.resolve(process.cwd(), projectName);
+        if (fs.existsSync(targetDir)) {
+            console.error(`Error: directory '${projectName}' already exists.`);
+            process.exit(1);
+        }
+        // Network selection
+        let networkKey = opts.network;
+        if (!networkKey || !NETWORKS[networkKey]) {
+            if (isNonInteractive) {
+                networkKey = "arbitrum-one";
+            }
+            else {
+                networkKey = await (0, prompts_1.select)({
+                    message: "Network:",
+                    choices: Object.entries(NETWORKS).map(([key, net]) => ({
+                        name: `${net.name} (chain ${net.chainId})`,
+                        value: key,
+                    })),
+                    default: "arbitrum-one",
+                });
+            }
+        }
+        const network = NETWORKS[networkKey] || NETWORKS["arbitrum-one"];
+        // RPC URL
+        let rpcUrl = opts.rpc;
+        if (!rpcUrl) {
+            if (isNonInteractive) {
+                rpcUrl = network.rpcUrl;
+            }
+            else {
+                rpcUrl = await (0, prompts_1.input)({
+                    message: "RPC URL:",
+                    default: network.rpcUrl,
+                    validate: (v) => v.trim().length > 0 || "RPC URL cannot be empty",
+                });
+            }
+        }
+        rpcUrl = rpcUrl.trim();
+        // Contract Name
+        let contractName = opts.contractName;
+        if (!contractName) {
+            if (isNonInteractive) {
+                contractName = "TokenContract";
+            }
+            else {
+                contractName = await (0, prompts_1.input)({
+                    message: "Contract name (used for ABI file and YAML):",
+                    default: "TokenContract",
+                    validate: (v) => /^[A-Za-z][A-Za-z0-9]*$/.test(v.trim()) ||
+                        "Must be alphanumeric, starting with a letter",
+                });
+            }
+        }
+        contractName = contractName.trim();
+        // Contract Address
+        let contractAddress = opts.address;
+        if (!contractAddress) {
+            if (isNonInteractive) {
+                contractAddress = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
+            }
+            else {
+                contractAddress = await (0, prompts_1.input)({
+                    message: "Contract address:",
+                    default: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+                    validate: (v) => /^0x[0-9a-fA-F]{40}$/.test(v.trim()) || "Must be a valid 0x address",
+                });
+            }
+        }
+        contractAddress = contractAddress.trim();
+        // Start Block
+        let startBlockStr = opts.startBlock;
+        if (!startBlockStr) {
+            if (isNonInteractive) {
+                startBlockStr = "0";
+            }
+            else {
+                startBlockStr = await (0, prompts_1.input)({
+                    message: "Start block:",
+                    default: "0",
+                    validate: (v) => /^\d+$/.test(v.trim()) || "Must be a non-negative integer",
+                });
+            }
+        }
+        const answers = {
+            projectName,
+            networkName: network.name,
+            chainId: network.chainId,
+            rpcUrl,
+            contractName,
+            contractAddress,
+            startBlock: parseInt(startBlockStr.trim(), 10),
+        };
+        console.log(`Scaffolding in ./${projectName}/ ...\n`);
+        // Directory structure
+        fs.mkdirSync(path.join(targetDir, "abis"), { recursive: true });
+        fs.mkdirSync(path.join(targetDir, "src"), { recursive: true });
+        fs.mkdirSync(path.join(targetDir, "build"), { recursive: true });
+        // logrix.yaml
+        fs.writeFileSync(path.join(targetDir, "logrix.yaml"), (0, templates_1.logrixYamlTemplate)(answers));
+        // schema.graphql
+        fs.writeFileSync(path.join(targetDir, "schema.graphql"), (0, templates_1.schemaGraphqlTemplate)());
+        // Placeholder ABI
+        fs.writeFileSync(path.join(targetDir, "abis", `${answers.contractName}.json`), JSON.stringify(templates_1.ERC20_ABI, null, 2));
+        // src/mapping.ts
+        fs.writeFileSync(path.join(targetDir, "src", "mapping.ts"), (0, templates_1.mappingTemplate)(answers.contractName));
+        // package.json
+        fs.writeFileSync(path.join(targetDir, "package.json"), JSON.stringify((0, templates_1.packageJsonTemplate)(projectName), null, 2));
+        // tsconfig.json (AS config)
+        fs.writeFileSync(path.join(targetDir, "tsconfig.json"), JSON.stringify((0, templates_1.tsconfigTemplate)(), null, 2));
+        // .gitignore
+        fs.writeFileSync(path.join(targetDir, ".gitignore"), (0, templates_1.gitignoreTemplate)());
+        // README.md
+        fs.writeFileSync(path.join(targetDir, "README.md"), (0, templates_1.readmeTemplate)(projectName));
+        console.log("Done. Next steps:\n");
+        console.log(`  cd ${projectName}`);
+        console.log("  npm install");
+        console.log("  npm run codegen");
+        console.log("  npm run validate");
+        console.log("  npm run build\n");
+    });
+    return cmd;
+}

package/dist/commands/test.js

@@ -0,0 +1,124 @@
+"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.testCommand = testCommand;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const yaml_1 = require("yaml");
+function testCommand() {
+    const cmd = new commander_1.Command("test");
+    cmd
+        .description("Run local tests for indexer handlers, configuration, and WASM build")
+        .argument("[testFile]", "Optional specific test file to run")
+        .option("--watch", "Watch mode (rerun on file changes)")
+        .action(async (testFile, opts) => {
+        const projectDir = process.cwd();
+        const configPath = path.join(projectDir, "logrix.yaml");
+        console.log("\nLogrix Test Runner");
+        console.log("------------------------------------------");
+        if (!fs.existsSync(configPath)) {
+            console.error("Error: logrix.yaml not found. Run `logrix test` from your project root.");
+            process.exit(1);
+        }
+        let failed = false;
+        // 1. Validate configuration
+        process.stdout.write("  [1/3] Validating configuration & schema... ");
+        try {
+            const configContent = fs.readFileSync(configPath, "utf-8");
+            const config = (0, yaml_1.parse)(configContent);
+            if (!config.dataSources || config.dataSources.length === 0) {
+                throw new Error("No dataSources found in logrix.yaml");
+            }
+            const schemaPath = path.join(projectDir, "schema.graphql");
+            if (!fs.existsSync(schemaPath)) {
+                throw new Error("schema.graphql missing");
+            }
+            console.log("PASSED");
+        }
+        catch (e) {
+            console.log("FAILED");
+            console.error(`        ${e.message}`);
+            failed = true;
+        }
+        // 2. Compile AssemblyScript mapping
+        process.stdout.write("  [2/3] Compiling AssemblyScript handlers... ");
+        try {
+            const ascBin = path.join(projectDir, "node_modules", ".bin", "asc");
+            const ascCmd = fs.existsSync(ascBin) ? ascBin : "npx asc";
+            (0, child_process_1.execSync)(`${ascCmd} src/mapping.ts -o build/test_mapping.wasm -O3 --runtime stub --noAssert`, { cwd: projectDir, stdio: "pipe" });
+            console.log("PASSED");
+        }
+        catch (e) {
+            console.log("FAILED");
+            console.error(`        ${e.stderr ? e.stderr.toString() : e.message}`);
+            failed = true;
+        }
+        // 3. Run user test suite if tests directory or file exists
+        const testsDir = path.join(projectDir, "tests");
+        const hasTestsDir = fs.existsSync(testsDir);
+        if (testFile || hasTestsDir) {
+            process.stdout.write("  [3/3] Running handler unit tests... ");
+            try {
+                const target = testFile
+                    ? path.resolve(projectDir, testFile)
+                    : `${testsDir}/**/*.test.{ts,js}`;
+                (0, child_process_1.execSync)(`node --test ${target}`, {
+                    cwd: projectDir,
+                    stdio: "inherit",
+                });
+                console.log("PASSED");
+            }
+            catch {
+                console.log("FAILED");
+                failed = true;
+            }
+        }
+        else {
+            console.log("  [3/3] Handler unit tests... SKIPPED (no tests/ directory found)");
+            console.log("        Create tests in tests/*.test.ts to add custom unit tests.");
+        }
+        console.log("------------------------------------------");
+        if (failed) {
+            console.error("Result: TESTS FAILED\n");
+            process.exit(1);
+        }
+        else {
+            console.log("Result: ALL CHECKS & TESTS PASSED\n");
+        }
+    });
+    return cmd;
+}

package/dist/commands/validate.js

@@ -0,0 +1,159 @@
+"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.validateCommand = validateCommand;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+function validateCommand() {
+    const cmd = new commander_1.Command("validate");
+    cmd
+        .description("Validate project configuration, ABIs, schema, and handler files")
+        .action(() => {
+        const projectDir = process.cwd();
+        let hasErrors = false;
+        console.log("\nValidating Logrix project in:", projectDir, "\n");
+        // 1. Check logrix.yaml
+        const configPath = path.join(projectDir, "logrix.yaml");
+        if (!fs.existsSync(configPath)) {
+            console.error("  [FAIL] logrix.yaml not found.");
+            process.exit(1);
+        }
+        let config;
+        try {
+            config = (0, yaml_1.parse)(fs.readFileSync(configPath, "utf-8"));
+            console.log("  [OK] logrix.yaml syntax valid.");
+        }
+        catch (e) {
+            console.error(`  [FAIL] logrix.yaml syntax error: ${e.message}`);
+            process.exit(1);
+        }
+        if (!config.dataSources || !Array.isArray(config.dataSources) || config.dataSources.length === 0) {
+            console.error("  [FAIL] logrix.yaml must contain at least one dataSource in 'dataSources'.");
+            hasErrors = true;
+        }
+        else {
+            console.log(`  [OK] Found ${config.dataSources.length} dataSource(s).`);
+        }
+        // 2. Check each dataSource
+        if (Array.isArray(config.dataSources)) {
+            for (let i = 0; i < config.dataSources.length; i++) {
+                const ds = config.dataSources[i];
+                const dsName = ds.name || `dataSource[${i}]`;
+                if (!ds.name) {
+                    console.error(`  [FAIL] ${dsName}: missing 'name' attribute.`);
+                    hasErrors = true;
+                }
+                const addr = ds.source?.address;
+                if (!addr || !/^0x[0-9a-fA-F]{40}$/.test(addr)) {
+                    console.error(`  [FAIL] ${dsName}: source.address '${addr}' is not a valid 40-character 0x hex address.`);
+                    hasErrors = true;
+                }
+                else {
+                    console.log(`  [OK] ${dsName}: contract address valid (${addr}).`);
+                }
+                // Check ABIs
+                const abis = ds.mapping?.abis || [];
+                if (!Array.isArray(abis) || abis.length === 0) {
+                    console.error(`  [FAIL] ${dsName}: mapping.abis must list at least one ABI file.`);
+                    hasErrors = true;
+                }
+                else {
+                    for (const abiRef of abis) {
+                        const abiFile = path.resolve(projectDir, abiRef.file);
+                        if (!fs.existsSync(abiFile)) {
+                            console.error(`  [FAIL] ${dsName}: ABI file not found at ${abiRef.file}`);
+                            hasErrors = true;
+                        }
+                        else {
+                            try {
+                                const parsed = JSON.parse(fs.readFileSync(abiFile, "utf-8"));
+                                if (!Array.isArray(parsed)) {
+                                    console.error(`  [FAIL] ${dsName}: ABI file ${abiRef.file} is not a JSON array.`);
+                                    hasErrors = true;
+                                }
+                                else {
+                                    const eventCount = parsed.filter((item) => item.type === "event").length;
+                                    console.log(`  [OK] ${dsName}: ABI ${abiRef.name} loaded with ${eventCount} event definition(s).`);
+                                }
+                            }
+                            catch (e) {
+                                console.error(`  [FAIL] ${dsName}: ABI file ${abiRef.file} is invalid JSON: ${e.message}`);
+                                hasErrors = true;
+                            }
+                        }
+                    }
+                }
+                // Check handler mapping file
+                const mappingFile = path.resolve(projectDir, ds.mapping?.file || "src/mapping.ts");
+                const mappingSrc = path.resolve(projectDir, "src/mapping.ts");
+                if (!fs.existsSync(mappingSrc)) {
+                    console.error(`  [FAIL] ${dsName}: handler source file not found at src/mapping.ts`);
+                    hasErrors = true;
+                }
+                else {
+                    console.log(`  [OK] ${dsName}: handler entry point exists at src/mapping.ts`);
+                }
+            }
+        }
+        // 3. Check schema.graphql
+        const schemaPath = path.join(projectDir, "schema.graphql");
+        if (!fs.existsSync(schemaPath)) {
+            console.error("  [FAIL] schema.graphql not found.");
+            hasErrors = true;
+        }
+        else {
+            const schemaContent = fs.readFileSync(schemaPath, "utf-8");
+            const entityCount = (schemaContent.match(/type\s+\w+\s+@entity/g) || []).length;
+            if (entityCount === 0) {
+                console.error("  [FAIL] schema.graphql has no @entity types declared.");
+                hasErrors = true;
+            }
+            else {
+                console.log(`  [OK] schema.graphql valid with ${entityCount} @entity definition(s).`);
+            }
+        }
+        console.log("");
+        if (hasErrors) {
+            console.error("Validation failed. Please address the errors above before building.\n");
+            process.exit(1);
+        }
+        else {
+            console.log("Validation passed successfully! All configuration files, ABIs, and schemas are valid.\n");
+        }
+    });
+    return cmd;
+}

package/dist/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const codegen_1 = require("./commands/codegen");
+const build_1 = require("./commands/build");
+const add_1 = require("./commands/add");
+const validate_1 = require("./commands/validate");
+const export_values_1 = require("./commands/export_values");
+const test_1 = require("./commands/test");
+const program = new commander_1.Command();
+program
+    .name("logrix")
+    .description("Developer CLI for Logrix blockchain indexers")
+    .version("0.3.0");
+program.addCommand((0, init_1.initCommand)());
+program.addCommand((0, add_1.addCommand)());
+program.addCommand((0, codegen_1.codegenCommand)());
+program.addCommand((0, validate_1.validateCommand)());
+program.addCommand((0, build_1.buildCommand)());
+program.addCommand((0, export_values_1.exportValuesCommand)());
+program.addCommand((0, test_1.testCommand)());
+program.parse(process.argv);