npm - @bankofai/x402-cli - Versions diffs - 1.0.1-beta.7 → 1.0.1-beta.9 - Mend

@bankofai/x402-cli 1.0.1-beta.7 → 1.0.1-beta.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/args.js +96 -0
package/dist/catalog-commands.js +558 -0
package/dist/cli.js +49 -1372
package/dist/daemon.js +47 -0
package/dist/gateway/catalog.js +56 -0
package/dist/gateway/cli.js +0 -0
package/dist/gateway/config.js +48 -3
package/dist/gateway/index.js +3 -0
package/dist/gateway/server.js +95 -18
package/dist/gateway-commands.js +145 -0
package/dist/help.js +169 -0
package/dist/http-client.js +82 -0
package/dist/output.js +91 -0
package/dist/provider-config.js +94 -0
package/dist/tokens.js +2 -2
package/dist/x402.js +8 -2
package/package.json +4 -4

package/dist/help.js ADDED Viewed

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+export function getVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return String(pkg.version ?? "0.0.0");
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export function helpText(topic = "root") {
+    const sections = {
+        root: `x402-cli ${getVersion()}
+Usage:
+  x402-cli <command> [options]
+Commands:
+  pay <url>                 Pay an x402-protected URL
+  serve                     Run a local x402 paywall endpoint
+  roundtrip                 Start serve, pay it, then exit
+  gateway <command>         Manage local gateway provider files
+  catalog <command>         Search, cache, and export provider catalog assets
+Global options:
+  -h, --help                Show help
+  -V, --version             Show version
+  --json                    Print machine-readable JSON envelope
+  --human                   Print human-readable output (default)
+`,
+        pay: `Usage:
+  x402-cli pay <url> [options]
+Options:
+  --method <method>         HTTP method (default: GET)
+  --header "Name: Value"    Request header, repeatable
+  --body <body>             Request body for non-GET/HEAD methods
+  --network <caip2>         Require a specific network
+  --token <symbol>          Require a specific token
+  --scheme <scheme>         Require a specific x402 scheme
+  --gasfree-api-url <url>   Override the TRON GasFree relayer API URL
+  --max-gasfree-fee <amt>   Maximum GasFree relayer fee in token units
+  --max-gasfree-fee-raw <n> Maximum GasFree relayer fee in smallest units
+  --max-amount <amount>     Maximum human-readable payment amount
+  --max-raw-amount <amount> Maximum smallest-unit payment amount
+  --dry-run                 Read requirements but do not sign or pay
+  --private-key <hex>       Explicit payer private key (or PRIVATE_KEY/TRON_PRIVATE_KEY/EVM_PRIVATE_KEY)
+  --rpc-url <url>           Explicit network RPC URL
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --json                    Print JSON envelope
+Examples:
+  x402-cli pay https://api.example.com/paid --dry-run --json
+  x402-cli pay https://api.example.com/paid --max-amount 0.01
+`,
+        serve: `Usage:
+  x402-cli serve --pay-to <address> [options]
+Options:
+  --pay-to <address>        Recipient wallet address
+  --amount <amount>         Human-readable token amount (default: 0.0001)
+  --raw-amount <amount>     Smallest-unit amount
+  --network <caip2>         Payment network (default: tron:0xcd8690dc)
+  --scheme <scheme>         Payment scheme: exact or exact_gasfree (default: exact)
+  --token <symbol>          Token symbol (default: USDT)
+  --asset <address>         Explicit token address
+  --decimals <count>        Token decimals for unregistered --asset
+  --host <host>             Bind host (default: 127.0.0.1)
+  --port <port>             Bind port (default: 4020)
+  --resource-url <url>      URL advertised in payment requirements
+  --facilitator-url <url>   Facilitator base URL
+  --timeout-ms <ms>         Facilitator timeout in milliseconds (default: 30000)
+  --daemon                  Run in background and print the child pid
+  --json                    Print JSON envelope
+Examples:
+  x402-cli serve --pay-to T... --network tron:0xcd8690dc --token USDT
+  x402-cli serve --pay-to 0x... --network eip155:97 --token USDT --amount 0.0001
+`,
+        roundtrip: `Usage:
+  x402-cli roundtrip --pay-to <address> [serve/pay options]
+`,
+        gateway: `Usage:
+  x402-cli gateway <search|start|check|scaffold|catalog> [options]
+Commands:
+  search <query>            Search a gateway/catalog artifact
+  start                     Start a local x402 gateway process
+  check <providers>         Validate provider.yml files
+  scaffold <name>           Write a starter provider.yml
+  catalog <command>         Build/check/search gateway catalog assets
+`,
+        "gateway-catalog": `Usage:
+  x402-cli gateway catalog <build|check|pay-assets|search> [options]
+Commands:
+  build <providers>         Build a local catalog from provider.yml files
+  check <providers>         Validate local provider.yml files
+  pay-assets <providers>    List payable endpoint assets
+  search <query>            Search a catalog artifact
+`,
+        catalog: `Usage:
+  x402-cli catalog <update|search|show|endpoints|pay-json|export-gateway|build> [options]
+Commands:
+  update                    Cache hosted/local catalog assets under ~/.cache
+  search <query>            Search providers
+  show <provider>           Show provider detail JSON
+  endpoints <provider>      List provider endpoints
+  pay-json <provider>       Print provider pay JSON
+  export-gateway <url>      Export catalog.json and pay.md from a gateway
+  build <providers>         Build catalog from provider.yml files
+Options:
+  --catalog <source>        catalog.json path or URL
+  --provider <fqn>          Provider FQN for export-gateway
+  --output-dir <dir>        Output directory for generated files
+  -n, --limit <count>       Search result limit
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --include-blocked         Include blocked providers in search
+  --json                    Print JSON envelope
+`,
+        "catalog-search": `Usage:
+  x402-cli catalog search <query> [--catalog <source>] [options]
+Options:
+  --catalog <source>        catalog.json path or URL
+  -n, --limit <count>       Search result limit
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --include-blocked         Include blocked providers in search
+  --json                    Print JSON envelope
+`,
+        "catalog-show": `Usage:
+  x402-cli catalog show <provider> [--catalog <source>] [options]
+Options:
+  --catalog <source>        catalog.json path or URL
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --json                    Print JSON envelope
+`,
+        "catalog-pay-json": `Usage:
+  x402-cli catalog pay-json <provider> [--catalog <source>] [options]
+Options:
+  --catalog <source>        catalog.json path or URL
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --raw                     Print raw pay payload instead of JSON envelope
+  --json                    Print JSON envelope
+`,
+        "catalog-endpoints": `Usage:
+  x402-cli catalog endpoints <provider> [--catalog <source>] [options]
+Options:
+  --catalog <source>        catalog.json path or URL
+  --timeout-ms <ms>         Network timeout in milliseconds (default: 30000)
+  --json                    Print JSON envelope
+`,
+        "catalog-export-gateway": `Usage:
+  x402-cli catalog export-gateway <gateway-url> --provider <fqn> [options]
+Options:
+  --provider <fqn>          Provider FQN to export
+  --output-dir <dir>        Output directory for generated files
+  --force                   Overwrite existing files
+  --json                    Print JSON envelope
+`,
+    };
+    return sections[topic] ?? sections.root;
+}

package/dist/http-client.js ADDED Viewed

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import { CliError, opt } from "./args.js";
+const MAX_HTTP_BODY_BYTES = 10 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export function positiveIntegerOption(options, key, fallback) {
+    const value = opt(options, key, String(fallback));
+    if (!/^\d+$/.test(value))
+        throw new CliError("INVALID_ARGUMENT", `--${key} must be a positive integer`, `Pass --${key} with a value greater than zero.`, 2);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0)
+        throw new CliError("INVALID_ARGUMENT", `--${key} must be a positive integer`, `Pass --${key} with a value greater than zero.`, 2);
+    return parsed;
+}
+export function timeoutMs(options) {
+    return options ? positiveIntegerOption(options, "timeout-ms", DEFAULT_TIMEOUT_MS) : DEFAULT_TIMEOUT_MS;
+}
+export async function fetchWithTimeout(input, init = {}, timeout = DEFAULT_TIMEOUT_MS, label = "request") {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        return await fetch(input, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError")
+            throw new Error(`${label} timed out after ${timeout}ms`);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function readBoundedText(response, label) {
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > MAX_HTTP_BODY_BYTES)
+        throw new Error(`${label} exceeds ${MAX_HTTP_BODY_BYTES} byte limit`);
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > MAX_HTTP_BODY_BYTES) {
+            await reader.cancel();
+            throw new Error(`${label} exceeds ${MAX_HTTP_BODY_BYTES} byte limit`);
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(bytes);
+}
+export async function readText(source, options) {
+    if (!source.startsWith("http://") && !source.startsWith("https://"))
+        return fs.readFileSync(source, "utf8");
+    const response = await fetchWithTimeout(source, {}, timeoutMs(options), `fetch ${source}`);
+    if (!response.ok)
+        throw new Error(`failed to fetch ${source}: ${response.status}`);
+    return readBoundedText(response, `response from ${source}`);
+}
+export async function readJson(source, options) {
+    return JSON.parse(await readText(source, options));
+}
+export async function responsePayload(response) {
+    const text = await readBoundedText(response, "HTTP response");
+    if ((response.headers.get("content-type") ?? "").toLowerCase().includes("json")) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    return text;
+}

package/dist/output.js ADDED Viewed

@@ -0,0 +1,91 @@
+import { CliError } from "./args.js";
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export function emit(args) {
+    const mode = args.mode ?? "human";
+    if (mode === "json") {
+        const envelope = { ok: !args.error, command: args.command };
+        if (args.network)
+            envelope.network = args.network;
+        if (args.scheme)
+            envelope.scheme = args.scheme;
+        if (args.error)
+            envelope.error = args.error;
+        else
+            envelope.result = args.result ?? null;
+        printJson(envelope);
+        return;
+    }
+    if (args.error) {
+        process.stderr.write(`ERROR ${args.command}: ${args.error.code}\n`);
+        process.stderr.write(`  ${args.error.message}\n`);
+        if (args.error.hint)
+            process.stderr.write(`  hint: ${args.error.hint}\n`);
+        if (args.error.details !== undefined)
+            process.stderr.write(`  details: ${JSON.stringify(args.error.details)}\n`);
+        return;
+    }
+    const suffix = [args.network, args.scheme].filter(Boolean).join(" ");
+    process.stdout.write(`OK ${args.command}${suffix ? ` (${suffix})` : ""}\n`);
+    if (args.result && typeof args.result === "object" && !Array.isArray(args.result)) {
+        for (const [key, value] of Object.entries(args.result)) {
+            if (value === undefined)
+                continue;
+            process.stdout.write(value && typeof value === "object" ? `  ${key}: ${JSON.stringify(value)}\n` : `  ${key}: ${value}\n`);
+        }
+    }
+    else if (args.result !== undefined)
+        process.stdout.write(`  ${args.result}\n`);
+}
+export function classify(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof CliError)
+        return { code: error.code, message, hint: error.hint, details: error.details };
+    const lower = message.toLowerCase();
+    if (lower.includes("missing private key") || lower.includes("could not find a wallet"))
+        return { code: "WALLET_NOT_CONFIGURED", message, hint: "Set PRIVATE_KEY, TRON_PRIVATE_KEY, EVM_PRIVATE_KEY, or configure agent-wallet with a payer wallet." };
+    if (lower.includes("wallets_config") || lower.includes("wallet config"))
+        return { code: "WALLET_CONFIG_CORRUPT", message, hint: "Check ~/.agent-wallet/wallets_config.json or recreate the local agent-wallet configuration." };
+    if (lower.includes("does not exist") && lower.includes("account [t"))
+        return { code: "TRON_ACCOUNT_NOT_ACTIVATED", message, hint: "Activate the TRON address by sending it a small amount of TRX before signing contract calls." };
+    if (lower.includes("permit2_insufficient_balance") || lower.includes("insufficient") && lower.includes("balance"))
+        return { code: "INSUFFICIENT_TOKEN_BALANCE", message, hint: "Fund the payer address with the exact token and network advertised by the provider, then retry." };
+    if (lower.includes("transfer_from_failed") || lower.includes("transferfrom failed"))
+        return { code: "TOKEN_TRANSFER_FAILED", message, hint: "Check token balance, token contract, payer address, and that the selected x402 route matches the provider requirement." };
+    if (lower.includes("insufficient funds for gas") || lower.includes("insufficient gas") || lower.includes("energy"))
+        return { code: "INSUFFICIENT_GAS", message, hint: "Fund the payer address with the native gas token for this network." };
+    if (lower.includes("deadline") || lower.includes("expired"))
+        return { code: "DEADLINE_OR_CLOCK_SKEW", message, hint: "Check local clock sync and retry with a fresh payment requirement." };
+    if (lower.includes("permittransferfrom") || lower.includes("invalid signature") || lower.includes("permit reverted"))
+        return { code: "PERMIT_REVERTED", message, hint: "The token or Permit2 contract rejected the signature; retry with a fresh requirement and verify token/network support." };
+    if (lower.includes("tokenregistry") && lower.includes("import"))
+        return { code: "SDK_API_DRIFT", message, hint: "Installed x402 SDK packages do not match this CLI; reinstall @bankofai/x402-cli and SDK dependencies." };
+    if (lower.includes("429") || lower.includes("too many requests") || lower.includes("rate limit"))
+        return { code: "RATE_LIMITED", message, hint: "Wait briefly and retry; the upstream service or RPC is rate limiting requests." };
+    if (lower.includes("402 response missing"))
+        return { code: "INVALID_X402_RESPONSE", message, hint: "The endpoint returned HTTP 402 without a PAYMENT-REQUIRED header." };
+    if (lower.includes("no matching payment requirement"))
+        return { code: "NO_MATCHING_PAYMENT_REQUIREMENT", message, hint: "Relax --network, --token, or --scheme, or use values offered by the provider." };
+    if (lower.includes("exceeds --max"))
+        return { code: "PAYMENT_AMOUNT_TOO_HIGH", message, hint: "Increase the max amount flag only if this provider price is expected." };
+    if (lower.includes("failed to fetch") || lower.includes("fetch failed") || lower.includes("econnrefused") || lower.includes("timed out"))
+        return { code: "NETWORK_ERROR", message, hint: "Check the URL, local server, proxy, and network connectivity." };
+    if (lower.includes(" is required") || lower.includes("must be") || lower.includes("invalid --") || lower.includes("mutually exclusive"))
+        return { code: lower.includes("required") ? "MISSING_ARGUMENT" : "INVALID_ARGUMENT", message, hint: "Run the command with --help to see valid usage and options." };
+    return { code: "IO_ERROR", message, hint: "Run with --json for structured output, and check the provider/gateway logs for details." };
+}
+export async function withSdkStdoutRedirect(enabled, fn) {
+    if (!enabled)
+        return fn();
+    const originalLog = console.log;
+    console.log = (...args) => {
+        process.stderr.write(`${args.map(arg => typeof arg === "string" ? arg : JSON.stringify(arg, null, 2)).join(" ")}\n`);
+    };
+    try {
+        return await fn();
+    }
+    finally {
+        console.log = originalLog;
+    }
+}

package/dist/provider-config.js ADDED Viewed

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { normalizeNetwork } from "./tokens.js";
+function readYaml(file) {
+    return YAML.parse(fs.readFileSync(file, "utf8"));
+}
+function expandEnv(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, name) => {
+        if (!(name in process.env))
+            throw new Error(`environment variable \${${name}} is not set`);
+        return process.env[name] ?? "";
+    });
+}
+function expandDeep(value) {
+    if (typeof value === "string")
+        return expandEnv(value);
+    if (Array.isArray(value))
+        return value.map(expandDeep);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expandDeep(item)]));
+    return value;
+}
+export function providerFiles(root) {
+    const stat = fs.statSync(root);
+    if (stat.isFile())
+        return [root];
+    const out = [];
+    for (const entry of fs.readdirSync(root, { recursive: true })) {
+        const file = path.join(root, String(entry));
+        if (file.endsWith("provider.yml") || file.endsWith("provider.yaml"))
+            out.push(file);
+    }
+    return out.sort();
+}
+export function providerPrice(endpoint) {
+    return endpoint?.metering?.dimensions?.[0]?.tiers?.[0]?.price_usd ?? 0;
+}
+export function validateProvider(provider, file = "provider.yml") {
+    const required = [["name", provider?.name], ["forward_url", provider?.forward_url], ["operator.network", provider?.operator?.network], ["operator.recipient", provider?.operator?.recipient]];
+    for (const [name, value] of required)
+        if (typeof value !== "string" || !value.trim())
+            throw new Error(`${file}: ${name} is required`);
+    try {
+        const url = new URL(provider.forward_url);
+        if (!["http:", "https:"].includes(url.protocol))
+            throw new Error("unsupported protocol");
+    }
+    catch {
+        throw new Error(`${file}: forward_url must be a valid http(s) URL`);
+    }
+    if (!Array.isArray(provider.endpoints) || !provider.endpoints.length)
+        throw new Error(`${file}: endpoints must contain at least one endpoint`);
+    const seen = new Set();
+    for (const endpoint of provider.endpoints) {
+        if (typeof endpoint.method !== "string" || typeof endpoint.path !== "string")
+            throw new Error(`${file}: each endpoint needs method and path`);
+        if (!endpoint.method.trim() || !endpoint.path.trim() || !endpoint.path.startsWith("/"))
+            throw new Error(`${file}: endpoint method/path must be non-empty and path must start with /`);
+        const price = providerPrice(endpoint);
+        if (!Number.isFinite(price) || price < 0)
+            throw new Error(`${file}: endpoint price_usd must be a finite number >= 0`);
+        const key = `${endpoint.method.toUpperCase()} ${endpoint.path}`;
+        if (seen.has(key))
+            throw new Error(`${file}: duplicate endpoint ${key}`);
+        seen.add(key);
+    }
+}
+export function loadProviderFile(file) {
+    const provider = expandDeep(readYaml(file));
+    validateProvider(provider, file);
+    provider.operator.network = normalizeNetwork(provider.operator.network);
+    provider.operator.scheme = provider.operator.scheme ?? "exact";
+    return provider;
+}
+export function providerAssetTransferMethod(provider) {
+    return provider.operator?.asset_transfer_method ?? provider.operator?.assetTransferMethod ?? "permit2";
+}
+export function providerScheme(provider) {
+    return provider.operator?.scheme ?? "exact";
+}
+export function providerCatalog(provider) {
+    return {
+        name: provider.name, title: provider.title ?? provider.name, description: provider.description ?? "",
+        category: provider.category ?? "other", service_url: provider.display?.service_url, tags: provider.display?.tags ?? [],
+        network: normalizeNetwork(provider.operator.network), currency: provider.operator.currencies?.usd?.[0] ?? "USDT",
+        endpoints: (provider.endpoints ?? []).map((endpoint) => ({
+            method: endpoint.method.toUpperCase(), path: `/providers/${provider.name}${endpoint.path}`, upstream_path: endpoint.path,
+            description: endpoint.description ?? "",
+            paid: providerPrice(endpoint) > 0 ? { scheme: providerScheme(provider), network: normalizeNetwork(provider.operator.network), currency: provider.operator.currencies?.usd?.[0] ?? "USDT", price_usd: providerPrice(endpoint) } : null,
+            x402_routes: providerPrice(endpoint) > 0 ? [{ provider: provider.name, network: normalizeNetwork(provider.operator.network), scheme: providerScheme(provider), assetTransferMethod: providerAssetTransferMethod(provider), url: `/providers/${provider.name}${endpoint.path}` }] : [],
+        })),
+    };
+}

package/dist/tokens.js CHANGED Viewed

@@ -110,8 +110,8 @@ export function assertRawAmount(value, name = "raw amount") {
     return value.replace(/^0+(?=\d)/, "");
 }
 export function toSmallestUnit(amount, decimals) {
-    if (!Number.isInteger(decimals) || decimals < 0)
-        throw new Error("token decimals must be a non-negative integer");
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255)
+        throw new Error("token decimals must be an integer between 0 and 255");
     if (!/^\d+(\.\d+)?$/.test(amount))
         throw new Error("amount must be a non-negative decimal string");
     const [whole, fraction = ""] = amount.split(".");

package/dist/x402.js CHANGED Viewed

@@ -106,7 +106,7 @@ function evmRpcUrl(network, explicit) {
         (chainId === "56" ? "https://bsc-dataseed.binance.org" : undefined) ||
         (chainId === "97" ? "https://data-seed-prebsc-1-s1.binance.org:8545" : undefined));
 }
-async function createTronWallet(privateKey) {
+async function createTronWallet(privateKey, maxGasfreeFeeRaw) {
     const rawKey = privateKey.replace(/^0x/, "");
     const tronWeb = new TronWeb({ fullHost: "https://api.trongrid.io" });
     const address = TronWeb.address.fromPrivateKey(rawKey);
@@ -115,6 +115,12 @@ async function createTronWallet(privateKey) {
     return {
         getAddress: () => address,
         async signTypedData(args) {
+            if (maxGasfreeFeeRaw !== undefined && args?.primaryType === "PermitTransfer") {
+                const maxFee = BigInt(args?.message?.maxFee ?? -1);
+                if (maxFee < 0n || maxFee > BigInt(maxGasfreeFeeRaw)) {
+                    throw new Error(`final GasFree maxFee ${maxFee} exceeds --max-gasfree-fee limit ${maxGasfreeFeeRaw}`);
+                }
+            }
             const signature = await signTronTypedData(tronWeb, args, rawKey);
             return signature.startsWith("0x") ? signature : `0x${signature}`;
         },
@@ -149,7 +155,7 @@ export async function createPaymentPayload(args) {
     }
     if (selected.network.startsWith("tron:")) {
         const privateKey = privateKeyFrom(["TRON_PRIVATE_KEY", "AGENT_WALLET_PRIVATE_KEY", "PRIVATE_KEY"], args.privateKey, ["tron_client", "payer", "default"]);
-        const wallet = await createTronWallet(privateKey);
+        const wallet = await createTronWallet(privateKey, selected.scheme === "exact_gasfree" ? args.maxGasfreeFeeRaw : undefined);
         const signer = await createClientTronSigner(wallet, {
             network: selected.network,
             rpcUrl: args.rpcUrl || process.env.TRON_RPC_URL,

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bankofai/x402-cli",
-  "version": "1.0.1-beta.7",
+  "version": "1.0.1-beta.9",
   "type": "module",
   "files": [
     "dist"
@@ -13,6 +13,7 @@
     "bundle:gateway": "node scripts/bundle-gateway.mjs",
     "prepack": "npm run build && npm run bundle:gateway",
     "test": "npm run build && node --test tests/*.test.mjs",
+    "test:package": "node scripts/test-package.mjs",
     "start": "node dist/cli.js",
     "dev": "tsx src/cli.ts"
   },
@@ -22,11 +23,10 @@
   "dependencies": {
     "@bankofai/x402-core": "1.0.1",
     "@bankofai/x402-evm": "1.0.1",
-    "@bankofai/x402-gateway": "1.0.1-beta.6",
+    "@bankofai/x402-gateway": "1.0.1-beta.10",
     "@bankofai/x402-tron": "1.0.1",
     "tronweb": "6.4.0",
-    "viem": "^2.55.0",
-    "yaml": "^2.8.2"
+    "viem": "^2.55.0"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",