mintbound-cli 0.1.0

package/dist/read.js

@@ -0,0 +1,131 @@
+import { Contract, JsonRpcProvider } from "ethers";
+import { ASC_ABI, ASC_ERRORS, CHAIN_INFO_ABI, CONTINUITY_ABI, ERC20_ABI, VAULT_ABI } from "./abi.js";
+import { CHAIN_INFO_ADDRESS, RPC, creditcoin, sepolia } from "./config.js";
+export function providers() {
+    return {
+        cc: new JsonRpcProvider(RPC.creditcoin, undefined, { staticNetwork: true }),
+        sep: new JsonRpcProvider(RPC.sepolia, undefined, { staticNetwork: true }),
+    };
+}
+/** Any read that is context rather than part of the invariant may fail softly. */
+async function soft(p, fallback) {
+    try {
+        return await p;
+    }
+    catch {
+        return fallback;
+    }
+}
+export async function readLive() {
+    const cc = creditcoin();
+    const sep = sepolia();
+    const { cc: ccProvider, sep: sepProvider } = providers();
+    const ascAddr = cc.contracts.MintBoundASC;
+    const wrapped = cc.contracts.WrappedAsset;
+    const sourceAsset = String(cc.config?.sourceAsset ?? sep.contracts.TestUSD);
+    const vaultAddr = String(cc.config?.canonicalVault ?? sep.contracts.ReserveVault);
+    const sourceChainKey = Number(cc.config?.sourceChainKey ?? 1);
+    const asc = new Contract(ascAddr, [...ASC_ABI, ...ASC_ERRORS], ccProvider);
+    const vault = new Contract(vaultAddr, VAULT_ABI, sepProvider);
+    const asset = new Contract(sourceAsset, ERC20_ABI, sepProvider);
+    const wrapper = new Contract(wrapped, ERC20_ABI, ccProvider);
+    const info = new Contract(CHAIN_INFO_ADDRESS, CHAIN_INFO_ABI, ccProvider);
+    const r = await asc.solvencyReport(sourceAsset);
+    const maxStaleness = Number(await asc.maxStalenessBlocks());
+    const [symbol, decimals] = await Promise.all([
+        soft(wrapper.symbol(), "wmTUSD"),
+        soft(wrapper.decimals().then(Number), 18),
+    ]);
+    const [sourceHead, vaultBalance, vaultEncumbered, emergencyEnabled, delay] = await Promise.all([
+        soft(sepProvider.getBlockNumber(), 0),
+        soft(asset.balanceOf(vaultAddr), 0n),
+        soft(vault.encumbered(sourceAsset), 0n),
+        soft(vault.emergencyEnabled(), true),
+        soft(vault.WITHDRAWAL_DELAY().then(Number), 0),
+    ]);
+    // Continuity is an optional module; a deployment without it simply scores zero on
+    // that obligation rather than failing the whole read.
+    let coveredThrough = 0;
+    let anchorHeight = 0;
+    if (cc.contracts.SolvencyContinuity) {
+        const cont = new Contract(cc.contracts.SolvencyContinuity, CONTINUITY_ABI, ccProvider);
+        coveredThrough = await soft(cont.coveredThrough(sourceAsset).then(Number), 0);
+        anchorHeight = await soft(cont.anchorHeight(sourceAsset).then(Number), 0);
+    }
+    // remoteChainKeys is an unbounded public array getter; probe until it reverts.
+    let registeredChains = 0;
+    for (let i = 0; i < 32; i++) {
+        try {
+            await asc.remoteChainKeys(sourceAsset, i);
+            registeredChains++;
+        }
+        catch {
+            break;
+        }
+    }
+    // A registered chain counts as reporting when its proven supply contributes to the
+    // aggregate. If totalLiabilities reverts the aggregate cannot be formed at all, which
+    // is exactly the freeze condition, so report zero coverage rather than guessing.
+    const liabilities = await soft(asc.totalLiabilities(sourceAsset), -1n);
+    const reportingChains = liabilities >= 0n ? registeredChains : 0;
+    const verifiedReserve = BigInt(r.verifiedReserve);
+    const encumberedReserve = BigInt(r.encumberedReserve);
+    const haircutBps = Number(r.haircutBps);
+    const unencumbered = verifiedReserve > encumberedReserve ? verifiedReserve - encumberedReserve : 0n;
+    const latestAttested = Number(r.latestAttestedHeight);
+    return {
+        asc: ascAddr,
+        vault: vaultAddr,
+        sourceAsset,
+        wrapped,
+        sourceChainKey,
+        symbol,
+        decimals,
+        verifiedReserve,
+        encumberedReserve,
+        outstandingSupply: BigInt(r.outstandingSupply),
+        // Mirrors MintBoundASC._effectiveReserve exactly: announced exits come off BEFORE
+        // the haircut. Displaying it any other way would let the readout and the
+        // enforcement disagree.
+        discountedReserve: (unencumbered * BigInt(haircutBps)) / 10000n,
+        maxMintable: BigInt(r.maxMintable),
+        collateralRatioBps: Number(r.collateralRatioBps),
+        haircutBps,
+        epoch: Number(r.epoch),
+        attestedAtHeight: Number(r.attestedAtHeight),
+        latestAttestedHeight: latestAttested,
+        stalenessBlocks: Number(r.stalenessBlocks),
+        maxStalenessBlocks: maxStaleness,
+        trustedParties: Number(r.trustedParties),
+        fresh: Boolean(r.fresh),
+        solvent: Boolean(r.solvent),
+        mintFrozen: Boolean(r.mintFrozen),
+        sourceHead,
+        vaultBalance,
+        vaultEncumbered,
+        emergencyEnabled,
+        withdrawalDelayBlocks: delay,
+        coveredThrough,
+        anchorHeight,
+        registeredChains,
+        reportingChains,
+    };
+}
+export function toAssuranceInput(s) {
+    return {
+        trustedParties: s.trustedParties,
+        fresh: s.fresh,
+        stalenessBlocks: s.stalenessBlocks,
+        maxStalenessBlocks: s.maxStalenessBlocks,
+        withdrawalDelayBlocks: s.withdrawalDelayBlocks,
+        // Detection latency is the live gap between the source tip and what Creditcoin has
+        // attested. Measured, not assumed — it moves, and the margin has to hold against
+        // whatever it actually is right now.
+        detectionLatencyBlocks: Math.max(s.sourceHead - s.latestAttestedHeight, 0),
+        registeredChains: s.registeredChains,
+        reportingChains: s.reportingChains,
+        coveredThrough: s.coveredThrough,
+        anchorHeight: s.anchorHeight,
+        emergencyRenounced: !s.emergencyEnabled,
+    };
+}

package/dist/render.js

@@ -0,0 +1,51 @@
+const ESC = String.fromCharCode(27);
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (code) => (s) => useColor ? `${ESC}[${code}m${s}${ESC}[0m` : s;
+export const c = {
+    dim: wrap("2"),
+    bold: wrap("1"),
+    green: wrap("32"),
+    red: wrap("31"),
+    yellow: wrap("33"),
+    cyan: wrap("36"),
+    grey: wrap("90"),
+};
+export const TICK = "✓";
+export const CROSS = "✗";
+export function rule(width = 68) {
+    console.log(c.grey("─".repeat(width)));
+}
+export function heading(title) {
+    console.log("");
+    console.log(c.bold(title));
+    rule();
+}
+export function step(n, total, text) {
+    process.stdout.write(c.grey(`[${n}/${total}] `) + text);
+}
+export function stepOk(text) {
+    console.log(" " + c.green(TICK) + " " + c.dim(text));
+}
+export function stepFail(text) {
+    console.log(" " + c.red(CROSS) + " " + c.dim(text));
+}
+export function kv(key, value, pad = 22) {
+    console.log(`  ${c.grey(key.padEnd(pad))}${value}`);
+}
+/** Format a base-10 fixed-point integer without pulling in a bignum formatter. */
+export function units(v, decimals = 18, dp = 2) {
+    const neg = v < 0n;
+    const abs = neg ? -v : v;
+    const base = 10n ** BigInt(decimals);
+    const whole = abs / base;
+    const frac = abs % base;
+    const fracStr = frac.toString().padStart(decimals, "0").slice(0, dp).replace(/0+$/, "");
+    const group = whole.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    return `${neg ? "-" : ""}${group}${fracStr ? "." + fracStr : ""}`;
+}
+export function bar(fraction, width = 28) {
+    const clamped = Math.max(0, Math.min(1, Number.isFinite(fraction) ? fraction : 0));
+    const filled = Math.round(clamped * width);
+    const body = "█".repeat(filled) + c.grey("░".repeat(width - filled));
+    return clamped >= 1 ? c.green(body) : clamped >= 0.5 ? c.cyan(body) : c.yellow(body);
+}

package/dist/revert.js

@@ -0,0 +1,37 @@
+/**
+ * Turn a reverted call into a sentence a human can read.
+ *
+ * ethers' `shortMessage` gives up on custom errors and says "unknown custom error" even
+ * when the ABI is right there and the payload decodes perfectly. That matters here: a
+ * revert IS the product, so reporting it as unknown makes a correct rejection look like
+ * a malfunction. Decode from the raw data first, and only fall back to string scraping.
+ */
+export function describeRevert(iface, e) {
+    const data = e?.data ?? e?.info?.error?.data ?? e?.error?.data;
+    if (typeof data === "string" && data.length >= 10 && data !== "0x") {
+        try {
+            const parsed = iface.parseError(data);
+            if (parsed) {
+                // Solidity's require-string revert decodes as Error(string). Unwrap it —
+                // "Error(Merkle proof validation failed)" reads worse than the message itself.
+                if (parsed.name === "Error")
+                    return String(parsed.args[0]);
+                if (parsed.name === "Panic")
+                    return `Panic(0x${BigInt(parsed.args[0]).toString(16)})`;
+                const args = parsed.args.map((a) => String(a)).join(", ");
+                return args ? `${parsed.name}(${args})` : `${parsed.name}()`;
+            }
+        }
+        catch {
+            // Not one of ours — fall through to the string forms below.
+        }
+    }
+    const msg = String(e?.shortMessage ?? e?.reason ?? e?.message ?? e);
+    const quoted = msg.match(/reverted with[^:]*: ?"?([^"]+)"?/);
+    if (quoted?.[1])
+        return quoted[1].trim();
+    const named = msg.match(/[A-Z][A-Za-z]+\([^)]*\)/);
+    if (named?.[0])
+        return named[0];
+    return msg.slice(0, 110);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "mintbound-cli",
+  "version": "0.1.0",
+  "description": "Verify MintBound's solvency evidence yourself, against live chains, with no keys and no funds.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mintbound": "dist/index.js",
+    "mintbound-cli": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@gluwa/usc-sdk": "0.18.0",
+    "ethers": "^6.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lawalgiyath/MintGuard.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "creditcoin",
+    "attestcoin",
+    "proof-of-reserve",
+    "solvency",
+    "cross-chain",
+    "rwa",
+    "wrapped-assets"
+  ],
+  "engines": {
+    "node": ">=20"
+  }
+}