@logrix/sdk 0.3.0 → 0.3.2

package/README.md

@@ -24,11 +24,11 @@ npm test
 
 ### `logrix init [name]`
 
-Scaffolds a new indexer project. Run interactively or pass flags for CI/CD automation.
+Scaffolds a new indexer project with built-in presets for 26+ popular mainnets and testnets. Run interactively or pass flags for CI/CD automation.
 
 Options:
 - `-y, --yes` -- non-interactive mode using sensible defaults
-- `--network <name>` -- network preset (`arbitrum-one`, `ethereum`, `base`, `polygon`, `sepolia`)
+- `--network <name>` -- network preset (`arbitrum-one`, `ethereum`, `base`, `optimism`, `polygon`, `bsc`, `avalanche`, `sepolia`, etc.)
 - `--rpc <url>` -- custom RPC endpoint
 - `--contract-name <name>` -- contract name
 - `--address <address>` -- target contract 0x address
@@ -51,6 +51,23 @@ my-indexer/
 
 ---
 
+### `logrix status`
+
+Checks live JSON-RPC connectivity, measures round-trip latency, verifies chain ID match, checks latest block height, and verifies that target smart contracts are deployed with on-chain bytecode.
+
+```bash
+npx logrix status
+```
+
+Output includes:
+- Network Name & Chain ID verification
+- RPC reachability and response latency (ms)
+- Latest chain block number
+- Contract deployment verification (`eth_getCode` bytecode inspection)
+- Sync scope and remaining block delta
+
+---
+
 ### `logrix add contract <name>`
 
 Adds an additional smart contract to an existing `logrix.yaml` project for multi-contract indexing.
@@ -62,7 +79,7 @@ npx logrix add contract SecondaryToken \
   --abi ./my-abis/SecondaryToken.json \
   --start-block 1000000
 
-# Add with automatic ABI fetch from Etherscan / Sourcify
+# Add with automatic ABI fetch from block explorers / Sourcify
 npx logrix add contract DaiToken \
   --address 0x6b175474e89094c44da98b954eedeac495271d0f \
   --fetch-abi
@@ -71,8 +88,8 @@ npx logrix add contract DaiToken \
 Options:
 - `--address <address>` -- contract address
 - `--abi <path>` -- path to local ABI JSON
-- `--fetch-abi` -- auto-fetch verified contract ABI from Etherscan / Sourcify
-- `--etherscan-key <key>` -- optional Etherscan API key for rate limits
+- `--fetch-abi` -- auto-fetch verified contract ABI from block explorers (Etherscan, Arbiscan, Basescan, Polygonscan, etc.) and Sourcify
+- `--etherscan-key <key>` -- optional block explorer API key for rate limits
 - `--start-block <block>` -- initial indexing block
 
 ---
@@ -96,7 +113,7 @@ npx logrix codegen
 ```
 
 Outputs:
-- `src/generated/events.ts` -- typed event and parameter classes (namespaced per contract), multi-contract address constants, and router helpers
+- `src/generated/events.ts` -- typed event and parameter classes (namespaced per contract), multi-contract address constants, router helpers, and dynamic ABI decoding (`string`, `bytes`)
 - `src/generated/schema.ts` -- entity classes with static `.load(id)`, `.remove(id)`, and `.save()`, handling `@derivedFrom` relationships
 
 ---
@@ -165,6 +182,9 @@ Imported via `import { ... } from "@logrix/sdk"` in AssemblyScript handlers:
 | `Bytes` | Hex byte wrapper: `.fromHexString()`, `.fromUTF8()`, `.toHexString()`, `.toByteArray()`, `.length` |
 | `crypto.keccak256(data)` | Computes standard EVM Keccak-256 hash |
 | `formatUnits(val, decimals)` | Formats raw BigInt value into human-readable decimal string (default: 18) |
+| `decodeDynamicString(data, idx)` | Decodes dynamic string parameter from raw ABI event data |
+| `decodeDynamicBytes(data, idx)` | Decodes dynamic bytes parameter from raw ABI event data |
+| `createMockEventLog(config)` | Creates mock EventLog instance for testing mapping logic |
 | `log` | Structured logging: `log.info()`, `log.warning()`, `log.error()`, `log.debug()` |
 | `allocate(size)` | Guest memory allocator (must be re-exported by `mapping.ts`) |
 

package/dist/commands/add.js

@@ -40,40 +40,66 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml_1 = require("yaml");
 const templates_1 = require("../templates");
+const EXPLORER_APIS = {
+    1: "https://api.etherscan.io/api",
+    42161: "https://api.arbiscan.io/api",
+    10: "https://api-optimistic.etherscan.io/api",
+    8453: "https://api.basescan.org/api",
+    137: "https://api.polygonscan.com/api",
+    56: "https://api.bscscan.com/api",
+    43114: "https://api.snowtrace.io/api",
+    59144: "https://api.lineascan.build/api",
+    534352: "https://api.scrollscan.com/api",
+    81457: "https://api.blastscan.io/api",
+    100: "https://api.gnosisscan.io/api",
+    250: "https://api.ftmscan.com/api",
+    42220: "https://api.celoscan.io/api",
+    1101: "https://api-zkevm.polygonscan.com/api",
+    11155111: "https://api-sepolia.etherscan.io/api",
+    17000: "https://api-holesky.etherscan.io/api",
+    421614: "https://api-sepolia.arbiscan.io/api",
+    84532: "https://api-sepolia.basescan.org/api",
+    11155420: "https://api-sepolia-optimistic.etherscan.io/api",
+    80002: "https://api-amoy.polygonscan.com/api",
+    97: "https://api-testnet.bscscan.com/api",
+    43113: "https://api-testnet.snowtrace.io/api",
+    59141: "https://api-sepolia.lineascan.build/api",
+    534351: "https://api-sepolia.scrollscan.com/api",
+    168587773: "https://api-sepolia.blastscan.io/api",
+};
 /**
- * Fetch ABI from Etherscan (mainnet) or Sourcify as fallback.
- * Returns the parsed ABI array, or null if both fail.
+ * Fetch ABI from Etherscan/Etherscan-compatible chain explorer or Sourcify as fallback.
+ * Supports all 26+ major EVM mainnets and testnets.
  */
-async function fetchAbi(address, etherscanKey) {
+async function fetchAbi(address, chainId = 1, apiKey) {
     const addr = address.toLowerCase();
-    // Try Etherscan first if API key provided
-    if (etherscanKey) {
-        try {
-            const url = `https://api.etherscan.io/api?module=contract&action=getabi&address=${addr}&apikey=${etherscanKey}`;
-            const resp = await fetch(url);
-            const json = await resp.json();
-            if (json.status === "1" && json.result) {
-                const parsed = JSON.parse(json.result);
-                if (Array.isArray(parsed) && parsed.length > 0) {
-                    console.log(`  Fetched ABI from Etherscan for ${address}`);
-                    return parsed;
-                }
+    // Try Etherscan-compatible explorer API
+    const baseExplorer = EXPLORER_APIS[chainId] || EXPLORER_APIS[1];
+    try {
+        const keyParam = apiKey ? `&apikey=${apiKey}` : "";
+        const url = `${baseExplorer}?module=contract&action=getabi&address=${addr}${keyParam}`;
+        const resp = await fetch(url);
+        const json = await resp.json();
+        if (json.status === "1" && json.result) {
+            const parsed = JSON.parse(json.result);
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                console.log(`  Fetched verified ABI from block explorer for ${address}`);
+                return parsed;
             }
         }
-        catch {
-            // fall through
-        }
     }
-    // Try Sourcify (no key required)
+    catch {
+        // fall through to Sourcify
+    }
+    // Try Sourcify (supports any chainId, no API key required)
     try {
-        // Sourcify returns verified contracts at chainId 1 (mainnet)
-        const url = `https://repo.sourcify.dev/contracts/full_match/1/${addr}/metadata.json`;
+        const url = `https://repo.sourcify.dev/contracts/full_match/${chainId}/${addr}/metadata.json`;
         const resp = await fetch(url);
         if (resp.ok) {
             const json = await resp.json();
             const abi = json?.output?.abi;
             if (Array.isArray(abi) && abi.length > 0) {
-                console.log(`  Fetched ABI from Sourcify for ${address}`);
+                console.log(`  Fetched verified ABI from Sourcify for ${address}`);
                 return abi;
             }
         }
@@ -91,8 +117,8 @@ function addCommand() {
         .argument("[name]", "Name of the component")
         .option("--address <address>", "Contract address")
         .option("--abi <path>", "Path to ABI JSON file")
-        .option("--fetch-abi", "Auto-fetch ABI from Etherscan / Sourcify")
-        .option("--etherscan-key <key>", "Etherscan API key for ABI fetch (optional)")
+        .option("--fetch-abi", "Auto-fetch ABI from block explorer / Sourcify")
+        .option("--etherscan-key <key>", "Explorer API key for ABI fetch (optional)")
         .option("--start-block <block>", "Starting block number", "0")
         .action(async (type, nameArg, opts) => {
         const projectDir = process.cwd();
@@ -116,6 +142,7 @@ function addCommand() {
         if (!config.dataSources) {
             config.dataSources = [];
         }
+        const chainId = config.network?.chainId ?? 1;
         // 1. Resolve contract name
         let contractName = nameArg;
         if (!contractName) {
@@ -168,7 +195,6 @@ function addCommand() {
         fs.mkdirSync(abisDir, { recursive: true });
         const targetAbiFile = path.join(abisDir, `${contractName}.json`);
         if (opts.abi) {
-            // Explicit local file
             const sourceAbi = path.resolve(projectDir, opts.abi);
             if (!fs.existsSync(sourceAbi)) {
                 console.error(`Error: Specified ABI file not found: ${opts.abi}`);
@@ -178,9 +204,8 @@ function addCommand() {
             console.log(`  Copied ABI from ${opts.abi} to abis/${contractName}.json`);
         }
         else if (opts.fetchAbi) {
-            // Auto-fetch from Etherscan / Sourcify
-            console.log(`  Fetching ABI for ${contractAddress} ...`);
-            const abi = await fetchAbi(contractAddress, opts.etherscanKey);
+            console.log(`  Fetching ABI for ${contractAddress} (Chain ID: ${chainId}) ...`);
+            const abi = await fetchAbi(contractAddress, chainId, opts.etherscanKey);
             if (abi) {
                 fs.writeFileSync(targetAbiFile, JSON.stringify(abi, null, 2));
                 console.log(`  Saved fetched ABI to abis/${contractName}.json`);
@@ -191,7 +216,6 @@ function addCommand() {
             }
         }
         else if (!fs.existsSync(targetAbiFile)) {
-            // Default placeholder
             fs.writeFileSync(targetAbiFile, JSON.stringify(templates_1.ERC20_ABI, null, 2));
             console.log(`  Created default ERC-20 placeholder ABI at abis/${contractName}.json`);
         }

package/dist/commands/build.js

@@ -55,6 +55,13 @@ function buildCommand() {
             console.error(`Error: entry file not found: ${opts.entry}`);
             process.exit(1);
         }
+        // Check if generated bindings exist
+        const generatedSchema = path.join(projectDir, "src", "generated", "schema.ts");
+        const generatedEvents = path.join(projectDir, "src", "generated", "events.ts");
+        if (!fs.existsSync(generatedSchema) || !fs.existsSync(generatedEvents)) {
+            console.warn("Notice: Generated bindings (src/generated/) not found or incomplete.");
+            console.warn("Tip: Run `logrix codegen` before `logrix build` to generate typed classes.\n");
+        }
         // Ensure output directory exists
         fs.mkdirSync(path.dirname(outFile), { recursive: true });
         // Prefer logrix.yaml mapping.file if present
@@ -81,7 +88,7 @@ function buildCommand() {
             ascBin = "asc"; // global
         }
         const optimizeFlag = opts.debug ? "" : "--optimize";
-        const cmd = [
+        const ascCmd = [
             ascBin,
             resolvedEntry,
             "--config", "tsconfig.json",
@@ -91,14 +98,18 @@ function buildCommand() {
         ]
             .filter(Boolean)
             .join(" ");
-        console.log(`Running: ${cmd}\n`);
+        console.log(`Running: ${ascCmd}\n`);
         try {
-            (0, child_process_1.execSync)(cmd, { cwd: projectDir, stdio: "inherit" });
+            (0, child_process_1.execSync)(ascCmd, { cwd: projectDir, stdio: "inherit" });
             const stat = fs.statSync(outFile);
             console.log(`\nBuild complete: ${path.relative(projectDir, outFile)} (${stat.size} bytes)`);
         }
         catch {
             console.error("\nBuild failed.");
+            console.error("Troubleshooting tips:");
+            console.error("  1. Verify AssemblyScript types in src/mapping.ts (e.g. use BigInt / Address / Bytes from @logrix/sdk)");
+            console.error("  2. Run `logrix codegen` to refresh generated bindings");
+            console.error("  3. Run `logrix validate` to check configuration syntax\n");
             process.exit(1);
         }
     });

package/dist/commands/codegen.js

@@ -57,7 +57,7 @@ function solTypeToAs(solType) {
 function generateEventsTs(dataSources, projectDir) {
     const lines = [
         "// Auto-generated by `logrix codegen`. Do not edit.",
-        'import { EventLog, BigInt, Address, Bytes } from "@logrix/sdk";',
+        'import { EventLog, BigInt, Address, Bytes, decodeDynamicString, decodeDynamicBytes } from "@logrix/sdk";',
         "",
     ];
     // Contract address constants for multi-contract indexers
@@ -138,23 +138,31 @@ function generateEventsTs(dataSources, projectDir) {
                         topicIdx++;
                     }
                     else {
-                        lines.push(`    {`);
-                        lines.push(`      const dataHex = raw.data.startsWith("0x") ? raw.data.slice(2) : raw.data;`);
-                        lines.push(`      const offset = ${nonIndexedIdx * 64};`);
-                        lines.push(`      const rawWord = dataHex.length >= offset + 64 ? "0x" + dataHex.slice(offset, offset + 64) : (offset == 0 ? raw.data : "");`);
-                        if (asType === "BigInt") {
-                            lines.push(`      this.${inp.name} = BigInt.fromString(rawWord);`);
-                        }
-                        else if (asType === "Address") {
-                            lines.push(`      this.${inp.name} = Address.fromString(rawWord);`);
+                        if (inp.type === "string") {
+                            lines.push(`    this.${inp.name} = decodeDynamicString(raw.data, ${nonIndexedIdx});`);
                         }
-                        else if (asType === "Bytes") {
-                            lines.push(`      this.${inp.name} = Bytes.fromHexString(rawWord);`);
+                        else if (inp.type === "bytes") {
+                            lines.push(`    this.${inp.name} = decodeDynamicBytes(raw.data, ${nonIndexedIdx});`);
                         }
                         else {
-                            lines.push(`      this.${inp.name} = rawWord;`);
+                            lines.push(`    {`);
+                            lines.push(`      const dataHex = raw.data.startsWith("0x") ? raw.data.slice(2) : raw.data;`);
+                            lines.push(`      const offset = ${nonIndexedIdx * 64};`);
+                            lines.push(`      const rawWord = dataHex.length >= offset + 64 ? "0x" + dataHex.slice(offset, offset + 64) : (offset == 0 ? raw.data : "");`);
+                            if (asType === "BigInt") {
+                                lines.push(`      this.${inp.name} = BigInt.fromString(rawWord);`);
+                            }
+                            else if (asType === "Address") {
+                                lines.push(`      this.${inp.name} = Address.fromString(rawWord);`);
+                            }
+                            else if (asType === "Bytes") {
+                                lines.push(`      this.${inp.name} = Bytes.fromHexString(rawWord);`);
+                            }
+                            else {
+                                lines.push(`      this.${inp.name} = rawWord;`);
+                            }
+                            lines.push(`    }`);
                         }
-                        lines.push(`    }`);
                         nonIndexedIdx++;
                     }
                 }

package/dist/commands/init.js

@@ -33,19 +33,42 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NETWORKS = void 0;
 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" },
+exports.NETWORKS = {
+    // Mainnets
+    "ethereum": { name: "Ethereum Mainnet", chainId: 1, rpcUrl: "https://eth.llamarpc.com", category: "mainnet" },
+    "arbitrum-one": { name: "Arbitrum One", chainId: 42161, rpcUrl: "https://arb1.arbitrum.io/rpc", category: "mainnet" },
+    "base": { name: "Base Mainnet", chainId: 8453, rpcUrl: "https://mainnet.base.org", category: "mainnet" },
+    "optimism": { name: "Optimism Mainnet", chainId: 10, rpcUrl: "https://mainnet.optimism.io", category: "mainnet" },
+    "polygon": { name: "Polygon PoS", chainId: 137, rpcUrl: "https://polygon-rpc.com", category: "mainnet" },
+    "bsc": { name: "BNB Smart Chain", chainId: 56, rpcUrl: "https://binance.llamarpc.com", category: "mainnet" },
+    "avalanche": { name: "Avalanche C-Chain", chainId: 43114, rpcUrl: "https://api.avax.network/ext/bc/C/rpc", category: "mainnet" },
+    "linea": { name: "Linea Mainnet", chainId: 59144, rpcUrl: "https://rpc.linea.build", category: "mainnet" },
+    "scroll": { name: "Scroll Mainnet", chainId: 534352, rpcUrl: "https://rpc.scroll.io", category: "mainnet" },
+    "blast": { name: "Blast Mainnet", chainId: 81457, rpcUrl: "https://rpc.blast.io", category: "mainnet" },
+    "zksync": { name: "ZKsync Era", chainId: 324, rpcUrl: "https://mainnet.era.zksync.io", category: "mainnet" },
+    "gnosis": { name: "Gnosis Chain", chainId: 100, rpcUrl: "https://rpc.gnosischain.com", category: "mainnet" },
+    "fantom": { name: "Fantom Opera", chainId: 250, rpcUrl: "https://rpcapi.fantom.network", category: "mainnet" },
+    "celo": { name: "Celo Mainnet", chainId: 42220, rpcUrl: "https://forno.celo.org", category: "mainnet" },
+    "polygon-zkevm": { name: "Polygon zkEVM", chainId: 1101, rpcUrl: "https://zkevm-rpc.com", category: "mainnet" },
+    // Testnets
+    "sepolia": { name: "Ethereum Sepolia", chainId: 11155111, rpcUrl: "https://rpc.sepolia.org", category: "testnet" },
+    "holesky": { name: "Ethereum Holesky", chainId: 17000, rpcUrl: "https://ethereum-holesky-rpc.publicnode.com", category: "testnet" },
+    "arbitrum-sepolia": { name: "Arbitrum Sepolia", chainId: 421614, rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc", category: "testnet" },
+    "base-sepolia": { name: "Base Sepolia", chainId: 84532, rpcUrl: "https://sepolia.base.org", category: "testnet" },
+    "optimism-sepolia": { name: "Optimism Sepolia", chainId: 11155420, rpcUrl: "https://sepolia.optimism.io", category: "testnet" },
+    "polygon-amoy": { name: "Polygon Amoy", chainId: 80002, rpcUrl: "https://rpc-amoy.polygon.technology", category: "testnet" },
+    "bsc-testnet": { name: "BNB Smart Chain Testnet", chainId: 97, rpcUrl: "https://data-seed-prebsc-1-s1.binance.org:8545", category: "testnet" },
+    "avalanche-fuji": { name: "Avalanche Fuji", chainId: 43113, rpcUrl: "https://api.avax-test.network/ext/bc/C/rpc", category: "testnet" },
+    "linea-sepolia": { name: "Linea Sepolia", chainId: 59141, rpcUrl: "https://rpc.sepolia.linea.build", category: "testnet" },
+    "scroll-sepolia": { name: "Scroll Sepolia", chainId: 534351, rpcUrl: "https://sepolia-rpc.scroll.io", category: "testnet" },
+    "blast-sepolia": { name: "Blast Sepolia", chainId: 168587773, rpcUrl: "https://sepolia.blast.io", category: "testnet" },
 };
 function initCommand() {
     const cmd = new commander_1.Command("init");
@@ -53,7 +76,7 @@ function initCommand() {
         .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("--network <network>", "Network preset name (e.g. arbitrum-one, ethereum, base, sepolia)")
         .option("--rpc <url>", "Custom RPC endpoint URL")
         .option("--contract-name <name>", "Contract name")
         .option("--address <address>", "Contract target address")
@@ -83,22 +106,22 @@ function initCommand() {
         }
         // Network selection
         let networkKey = opts.network;
-        if (!networkKey || !NETWORKS[networkKey]) {
+        if (!networkKey || !exports.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})`,
+                    choices: Object.entries(exports.NETWORKS).map(([key, net]) => ({
+                        name: `[${net.category.toUpperCase()}] ${net.name} (Chain ID: ${net.chainId})`,
                         value: key,
                     })),
                     default: "arbitrum-one",
                 });
             }
         }
-        const network = NETWORKS[networkKey] || NETWORKS["arbitrum-one"];
+        const network = exports.NETWORKS[networkKey] || exports.NETWORKS["arbitrum-one"];
         // RPC URL
         let rpcUrl = opts.rpc;
         if (!rpcUrl) {
@@ -140,7 +163,7 @@ function initCommand() {
                 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",
+                    validate: (v) => /^0x[0-9a-fA-F]{40}$/.test(v.trim()) || "Must be a valid 0x hex address",
                 });
             }
         }
@@ -153,41 +176,34 @@ function initCommand() {
             }
             else {
                 startBlockStr = await (0, prompts_1.input)({
-                    message: "Start block:",
+                    message: "Start block (indexing starting point):",
                     default: "0",
                     validate: (v) => /^\d+$/.test(v.trim()) || "Must be a non-negative integer",
                 });
             }
         }
+        const startBlock = parseInt(startBlockStr.trim(), 10);
         const answers = {
             projectName,
-            networkName: network.name,
+            networkName: networkKey,
             chainId: network.chainId,
             rpcUrl,
             contractName,
             contractAddress,
-            startBlock: parseInt(startBlockStr.trim(), 10),
+            startBlock,
         };
-        console.log(`Scaffolding in ./${projectName}/ ...\n`);
-        // Directory structure
+        console.log(`\nScaffolding in ./${projectName}/ ...\n`);
+        // Create directories
         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
+        // Write files
         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, "abis", `${contractName}.json`), JSON.stringify(templates_1.ERC20_ABI, null, 2));
+        fs.writeFileSync(path.join(targetDir, "src", "mapping.ts"), (0, templates_1.mappingTemplate)(contractName));
         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}`);

package/dist/commands/status.js

@@ -0,0 +1,140 @@
+"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.statusCommand = statusCommand;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml_1 = require("yaml");
+async function jsonRpcCall(url, method, params = []) {
+    const start = Date.now();
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+        });
+        const latencyMs = Date.now() - start;
+        if (!res.ok) {
+            return { error: `HTTP ${res.status}: ${res.statusText}`, latencyMs };
+        }
+        const json = await res.json();
+        return { result: json.result, error: json.error, latencyMs };
+    }
+    catch (e) {
+        return { error: e.message, latencyMs: Date.now() - start };
+    }
+}
+function statusCommand() {
+    const cmd = new commander_1.Command("status");
+    cmd
+        .description("Check RPC connectivity, network block height, and contract deployment status")
+        .action(async () => {
+        const projectDir = process.cwd();
+        const configPath = path.join(projectDir, "logrix.yaml");
+        if (!fs.existsSync(configPath)) {
+            console.error("Error: logrix.yaml not found. Run this command from your project root.");
+            process.exit(1);
+        }
+        let config;
+        try {
+            config = (0, yaml_1.parse)(fs.readFileSync(configPath, "utf-8"));
+        }
+        catch (e) {
+            console.error(`Error parsing logrix.yaml: ${e.message}`);
+            process.exit(1);
+        }
+        const networkName = config.network?.name || "unspecified";
+        const configuredChainId = config.network?.chainId;
+        const rpcUrl = config.network?.rpcUrl;
+        console.log("\nLogrix Indexer Status");
+        console.log("============================================================");
+        console.log(`Network Name:     ${networkName}`);
+        console.log(`Configured Chain: ${configuredChainId ?? "Not set"}`);
+        console.log(`RPC Endpoint:     ${rpcUrl || "None"}`);
+        if (!rpcUrl) {
+            console.error("\nError: No RPC URL configured in logrix.yaml.");
+            console.log("============================================================\n");
+            process.exit(1);
+        }
+        // 1. Query block height
+        process.stdout.write("Connecting to RPC endpoint ... ");
+        const blockRes = await jsonRpcCall(rpcUrl, "eth_blockNumber");
+        if (blockRes.error || !blockRes.result) {
+            console.log("FAILED");
+            console.error(`RPC Error: ${JSON.stringify(blockRes.error)} (${blockRes.latencyMs} ms)`);
+            console.log("============================================================\n");
+            process.exit(1);
+        }
+        const latestBlock = parseInt(blockRes.result, 16);
+        console.log(`ONLINE (${blockRes.latencyMs} ms)`);
+        console.log(`Latest Block:     #${latestBlock.toLocaleString()}`);
+        // 2. Query chain ID
+        const chainRes = await jsonRpcCall(rpcUrl, "eth_chainId");
+        if (chainRes.result) {
+            const reportedChainId = parseInt(chainRes.result, 16);
+            const match = configuredChainId === reportedChainId;
+            console.log(`Chain ID Check:   Reported ${reportedChainId} (${match ? "VERIFIED MATCH" : "MISMATCH WARNING"})`);
+        }
+        // 3. Inspect contracts
+        const dataSources = config.dataSources || [];
+        console.log(`\nContracts Monitored (${dataSources.length}):`);
+        console.log("------------------------------------------------------------");
+        for (const ds of dataSources) {
+            const addr = ds.source?.address || "";
+            const name = ds.name || "Unnamed";
+            const startBlock = ds.source?.startBlock ?? 0;
+            if (!addr) {
+                console.log(`  - ${name}: [NO ADDRESS SPECIFIED]`);
+                continue;
+            }
+            const codeRes = await jsonRpcCall(rpcUrl, "eth_getCode", [addr, "latest"]);
+            const code = codeRes.result || "";
+            const isDeployed = code.length > 2 && code !== "0x" && code !== "0x0";
+            const byteSize = isDeployed ? (code.length - 2) / 2 : 0;
+            console.log(`  - Name:        ${name}`);
+            console.log(`    Address:     ${addr}`);
+            console.log(`    Deployed:    ${isDeployed ? `YES (${byteSize.toLocaleString()} bytes bytecode)` : "NO (Empty bytecode / Not found)"}`);
+            console.log(`    Start Block: #${startBlock.toLocaleString()}`);
+            if (latestBlock > startBlock) {
+                const lag = latestBlock - startBlock;
+                console.log(`    Sync Scope:  #${startBlock} -> #${latestBlock} (${lag.toLocaleString()} blocks to process)`);
+            }
+            console.log("");
+        }
+        console.log("============================================================\n");
+    });
+    return cmd;
+}

package/dist/index.js

@@ -9,11 +9,12 @@ 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 status_1 = require("./commands/status");
 const program = new commander_1.Command();
 program
     .name("logrix")
     .description("Developer CLI for Logrix blockchain indexers")
-    .version("0.3.0");
+    .version("0.3.2");
 program.addCommand((0, init_1.initCommand)());
 program.addCommand((0, add_1.addCommand)());
 program.addCommand((0, codegen_1.codegenCommand)());
@@ -21,4 +22,5 @@ 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.addCommand((0, status_1.statusCommand)());
 program.parse(process.argv);

package/index.ts

@@ -1,3 +1,4 @@
-// Root AssemblyScript entry point — re-exports the full runtime.
+// Root entry point -- re-exports runtime and testing utilities.
 // asc resolves @logrix/sdk to this file when building user handler projects.
 export * from "./src/runtime/index";
+export * from "./src/testing/index";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logrix/sdk",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Official CLI and AssemblyScript runtime library for Logrix blockchain indexers",
   "main": "index.ts",
   "bin": {
@@ -13,6 +13,7 @@
   "files": [
     "dist",
     "src/runtime",
+    "src/testing",
     "index.ts",
     "tsconfig.as.json",
     "README.md"

package/src/runtime/index.ts

@@ -258,6 +258,58 @@ export class Bytes {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Dynamic ABI Offset Decoding Helpers (Solidity Head/Tail)
+// ---------------------------------------------------------------------------
+
+function parseHexI32(hex: string): i32 {
+  let val: i32 = 0;
+  for (let i = 0; i < hex.length; i++) {
+    val = (val << 4) | parseHexChar(hex.charCodeAt(i));
+  }
+  return val;
+}
+
+export function decodeDynamicString(dataHex: string, paramIndex: i32): string {
+  let clean = dataHex.startsWith("0x") ? dataHex.slice(2) : dataHex;
+  const headOffset = paramIndex * 64;
+  if (clean.length < headOffset + 64) return "";
+  const ptrWord = clean.slice(headOffset, headOffset + 64);
+  const offsetBytes = parseHexI32(ptrWord);
+  const offsetHex = offsetBytes * 2;
+  if (clean.length < offsetHex + 64) return "";
+  const lenWord = clean.slice(offsetHex, offsetHex + 64);
+  const byteLen = parseHexI32(lenWord);
+  const contentHexStart = offsetHex + 64;
+  const contentHexEnd = contentHexStart + byteLen * 2;
+  if (clean.length < contentHexEnd) return "";
+  const contentHex = clean.slice(contentHexStart, contentHexEnd);
+  const bytes = new Uint8Array(byteLen);
+  for (let i = 0; i < byteLen; i++) {
+    const high = parseHexChar(contentHex.charCodeAt(i * 2));
+    const low = parseHexChar(contentHex.charCodeAt(i * 2 + 1));
+    bytes[i] = ((high << 4) | low) as u8;
+  }
+  return String.UTF8.decode(bytes.buffer);
+}
+
+export function decodeDynamicBytes(dataHex: string, paramIndex: i32): Bytes {
+  let clean = dataHex.startsWith("0x") ? dataHex.slice(2) : dataHex;
+  const headOffset = paramIndex * 64;
+  if (clean.length < headOffset + 64) return Bytes.fromHexString("0x");
+  const ptrWord = clean.slice(headOffset, headOffset + 64);
+  const offsetBytes = parseHexI32(ptrWord);
+  const offsetHex = offsetBytes * 2;
+  if (clean.length < offsetHex + 64) return Bytes.fromHexString("0x");
+  const lenWord = clean.slice(offsetHex, offsetHex + 64);
+  const byteLen = parseHexI32(lenWord);
+  const contentHexStart = offsetHex + 64;
+  const contentHexEnd = contentHexStart + byteLen * 2;
+  if (clean.length < contentHexEnd) return Bytes.fromHexString("0x");
+  const contentHex = clean.slice(contentHexStart, contentHexEnd);
+  return Bytes.fromHexString("0x" + contentHex);
+}
+
 // ---------------------------------------------------------------------------
 // Keccak-256 Implementation & Crypto namespace
 // ---------------------------------------------------------------------------

package/src/testing/index.ts

@@ -0,0 +1,29 @@
+import { EventLog } from "../runtime";
+
+export interface MockEventLogConfig {
+  address?: string;
+  blockNumber?: number;
+  blockHash?: string;
+  transactionHash?: string;
+  logIndex?: number;
+  blockTimestamp?: number;
+  topics?: string[];
+  data?: string;
+}
+
+/**
+ * Construct an EventLog instance pre-populated with test values.
+ * Useful for writing local unit tests for AssemblyScript/TypeScript mapping handlers.
+ */
+export function createMockEventLog(config: MockEventLogConfig = {}): EventLog {
+  const log = new EventLog();
+  log.address = config.address || "0x0000000000000000000000000000000000000000";
+  log.block_number = BigInt(config.blockNumber ?? 1) as any;
+  log.block_hash = config.blockHash || "0x0000000000000000000000000000000000000000000000000000000000000000";
+  log.transaction_hash = config.transactionHash || "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+  log.log_index = (config.logIndex ?? 0) as any;
+  log.block_timestamp = BigInt(config.blockTimestamp ?? 1700000000) as any;
+  log.topics = config.topics || [];
+  log.data = config.data || "0x";
+  return log;
+}