neozip-cli 0.90.0 → 0.95.0

package/dist/src/connection/funding.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLowWalletBalance = isLowWalletBalance;
+exports.formatLowBalanceFundingHint = formatLowBalanceFundingHint;
+exports.connectFund = connectFund;
+exports.formatFundResult = formatFundResult;
+/**
+ * neozip connect fund — request native gas for the local Data Wallet from the
+ * Token Service funding API.
+ *
+ * The Token Service sends a small fixed grant (policy-defined, e.g. 0.001 ETH,
+ * 4-hour cooldown) to the user's primary linked Data Wallet so on-chain
+ * operations can pay for gas. The recipient is chosen server-side from the
+ * account's primary wallet link — the client cannot redirect funds.
+ *
+ * Actions:
+ *   policy   Show the grant size/cooldown for a chain (no auth).
+ *   status   Show eligibility + recent grants (Bearer).
+ *   request  Request a grant to the Data Wallet (Bearer). [default]
+ */
+const neozip_blockchain_1 = require("neozip-blockchain");
+const token_service_1 = require("neozip-blockchain/token-service");
+const origin_1 = require("./origin");
+const cli_prefs_1 = require("./cli-prefs");
+const wallet_login_1 = require("./wallet-login");
+const store_1 = require("./store");
+const FAUCET_HINT = "Or get testnet ETH from https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet";
+/** Typical Token Service grant size — balances below this cannot reliably pay for gas. */
+const LOW_BALANCE_ETH = 0.001;
+/** True when the wallet likely needs a funding grant before on-chain operations. */
+function isLowWalletBalance(balanceEth) {
+    const n = typeof balanceEth === "number" ? balanceEth : Number.parseFloat(balanceEth);
+    return Number.isFinite(n) && n < LOW_BALANCE_ETH;
+}
+/** One-line hint for blockchain summaries and insufficient-balance errors. */
+function formatLowBalanceFundingHint() {
+    return "Low balance — request gas from the Token Service: neozip connect fund";
+}
+function resolveChain(input) {
+    if (typeof input.chainId === "number" && Number.isFinite(input.chainId)) {
+        return { chainId: input.chainId, network: input.network?.trim() || "" };
+    }
+    const network = (0, cli_prefs_1.resolveNetwork)(input.network);
+    const chainId = (0, neozip_blockchain_1.getChainIdByName)(network);
+    return { chainId: chainId ?? null, network };
+}
+async function connectFund(input) {
+    const action = input.action ?? "request";
+    const origin = (0, origin_1.resolveTokenServiceOrigin)(input.tokenServiceUrl);
+    const { chainId, network } = resolveChain(input);
+    if (chainId == null) {
+        return {
+            success: false,
+            action,
+            network,
+            chainId: null,
+            message: network
+                ? `Unknown network "${network}". Pass --chain <id> or a supported --network name.`
+                : "Could not resolve a chain. Pass --chain <id> or --network <name>.",
+        };
+    }
+    if (action === "policy") {
+        try {
+            const res = await (0, token_service_1.getFundingPolicy)(origin, chainId);
+            return {
+                success: true,
+                action,
+                network: res.network || network,
+                chainId: res.chainId,
+                policy: res.policy,
+                message: res.policy.enabled
+                    ? `Funding is available on ${res.network || network} (chain ${res.chainId}): ${res.policy.grantEth} per grant, ${res.policy.cooldownHours}h cooldown.`
+                    : `Funding is not enabled on ${res.network || network} (chain ${res.chainId}).`,
+            };
+        }
+        catch (err) {
+            return fundError(action, network, chainId, err);
+        }
+    }
+    // status + request both require a Bearer token. Renew silently if possible.
+    await (0, wallet_login_1.ensureFreshTokenServiceToken)({ tokenServiceUrl: input.tokenServiceUrl });
+    (0, store_1.applyActiveConnectionToEnv)();
+    const secrets = (0, store_1.readActiveConnectionSecrets)();
+    const accessToken = secrets?.accessToken?.trim();
+    const meta = (0, store_1.getActiveConnection)();
+    const recipientAddress = meta?.evmAddress ?? null;
+    if (!accessToken) {
+        return {
+            success: false,
+            action,
+            network,
+            chainId,
+            recipientAddress,
+            message: "No Token Service access token. Run neozip connect to set up an account, then retry.",
+            nextCommand: "neozip connect",
+        };
+    }
+    if (action === "status") {
+        try {
+            const status = await (0, token_service_1.getFundingStatus)(origin, accessToken, chainId);
+            const lines = [];
+            lines.push(status.enabled
+                ? `Funding enabled on chain ${chainId}.`
+                : `Funding not enabled on chain ${chainId}.`);
+            lines.push(`Data Wallet: ${status.recipientAddress ?? recipientAddress ?? "unknown"}`);
+            if (status.lastGrantAt)
+                lines.push(`Last grant: ${status.lastGrantAt}`);
+            if (status.nextEligibleAt) {
+                lines.push(`Next eligible: ${status.nextEligibleAt}`);
+            }
+            else if (status.enabled) {
+                lines.push("Eligible now.");
+            }
+            return {
+                success: true,
+                action,
+                network,
+                chainId,
+                recipientAddress: status.recipientAddress ?? recipientAddress,
+                status,
+                message: lines.join("\n"),
+                nextCommand: status.enabled ? "neozip connect fund" : undefined,
+            };
+        }
+        catch (err) {
+            return fundError(action, network, chainId, err, recipientAddress);
+        }
+    }
+    // action === "request"
+    try {
+        const grant = await (0, token_service_1.requestFundingGrant)(origin, accessToken, chainId);
+        if (grant.success) {
+            const where = grant.recipientAddress || recipientAddress || "your Data Wallet";
+            const tx = grant.transactionHash ? ` (tx ${grant.transactionHash})` : "";
+            return {
+                success: true,
+                action,
+                network,
+                chainId,
+                recipientAddress: grant.recipientAddress || recipientAddress,
+                grant,
+                message: `Sent ${grant.amountEth} to ${where}${tx}. Status: ${grant.status}.`,
+            };
+        }
+        // Server-side refusal (cooldown, no wallet, low treasury, …).
+        return {
+            success: false,
+            action,
+            network,
+            chainId,
+            recipientAddress: grant.recipientAddress || recipientAddress,
+            grant,
+            message: grant.error ?? `Funding request failed (${grant.errorCode ?? "unknown"}).`,
+            nextCommand: grant.errorCode === "NO_DATA_WALLET" ? "neozip connect" : undefined,
+        };
+    }
+    catch (err) {
+        return fundError(action, network, chainId, err, recipientAddress);
+    }
+}
+function fundError(action, network, chainId, err, recipientAddress) {
+    if (err instanceof token_service_1.FundingUnavailableError) {
+        return {
+            success: false,
+            action,
+            network,
+            chainId,
+            recipientAddress,
+            message: `This Token Service does not offer wallet funding. ${FAUCET_HINT}`,
+        };
+    }
+    return {
+        success: false,
+        action,
+        network,
+        chainId,
+        recipientAddress,
+        message: err instanceof Error ? err.message : String(err),
+    };
+}
+function formatFundResult(res) {
+    const lines = [res.message];
+    if (res.nextCommand)
+        lines.push(`Next: ${res.nextCommand}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=funding.js.map

package/dist/src/connection/incomplete-setup.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERACTIVE_CONNECT_COMMAND = void 0;
+exports.listReadableConnectionIds = listReadableConnectionIds;
+exports.tryAutoRecoverConnectionStore = tryAutoRecoverConnectionStore;
+exports.diagnoseUnrecoverableStore = diagnoseUnrecoverableStore;
+exports.formatUnrecoverableStoreMessage = formatUnrecoverableStoreMessage;
+exports.recommendedConnectCommand = recommendedConnectCommand;
+const store_1 = require("./store");
+const phase_1 = require("./phase");
+const promote_active_1 = require("./promote-active");
+exports.INTERACTIVE_CONNECT_COMMAND = "neozip connect";
+function listReadableConnectionIds() {
+    return (0, store_1.listConnectionIds)().filter((id) => {
+        return Boolean((0, store_1.readConnectionPublic)(id) && (0, store_1.readConnectionSecrets)(id));
+    });
+}
+/** Switch active to a ready or readable account when the current one cannot be unlocked. */
+function tryAutoRecoverConnectionStore() {
+    const promoted = (0, promote_active_1.promoteReadyActiveConnection)();
+    if (promoted.promoted && promoted.label) {
+        return {
+            recovered: true,
+            message: `Active account was incomplete; switched to ready account "${promoted.label}".`,
+        };
+    }
+    const activeId = (0, store_1.getActiveConnectionId)();
+    if (!activeId) {
+        return { recovered: false };
+    }
+    const activeMeta = (0, store_1.readConnectionPublic)(activeId);
+    const activeReadable = Boolean((0, store_1.readConnectionSecrets)(activeId));
+    if (activeMeta && activeReadable) {
+        return { recovered: false };
+    }
+    const readableIds = listReadableConnectionIds();
+    if (readableIds.length === 0) {
+        return { recovered: false };
+    }
+    const fallbackId = readableIds.find((id) => (0, phase_1.listReadyConnectionIds)().includes(id)) ?? readableIds[0];
+    const fallback = (0, store_1.selectConnection)(fallbackId);
+    return {
+        recovered: true,
+        message: `Previous active account could not be unlocked; switched to "${fallback.label}".`,
+    };
+}
+/** True when every saved account lacks readable secrets (corrupt, wrong machine, or test residue). */
+function diagnoseUnrecoverableStore() {
+    const ids = (0, store_1.listConnectionIds)();
+    if (ids.length === 0) {
+        return null;
+    }
+    const readableIds = listReadableConnectionIds();
+    if (readableIds.length > 0) {
+        return null;
+    }
+    const activeId = (0, store_1.getActiveConnectionId)();
+    const activeMeta = activeId ? (0, store_1.readConnectionPublic)(activeId) : null;
+    return {
+        kind: "all_secrets_unreadable",
+        connectionCount: ids.length,
+        activeConnectionId: activeId,
+        activeLabel: activeMeta?.label ?? null,
+        activeEmail: activeMeta?.email ?? null,
+    };
+}
+function formatUnrecoverableStoreMessage(diagnosis) {
+    const who = diagnosis.activeLabel && diagnosis.activeEmail
+        ? `${diagnosis.activeLabel} (${diagnosis.activeEmail})`
+        : diagnosis.activeLabel ?? diagnosis.activeConnectionId ?? "unknown";
+    return [
+        `Found ${diagnosis.connectionCount} saved account(s) but none can be unlocked.`,
+        `Active: ${who}.`,
+        "Credentials may be from another machine, corrupted, or an incomplete test setup.",
+        "Reset is recommended before continuing.",
+    ].join(" ");
+}
+function recommendedConnectCommand() {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    if (phase === "ready") {
+        return `${exports.INTERACTIVE_CONNECT_COMMAND} status`;
+    }
+    const meta = (0, store_1.getActiveConnection)();
+    return ((0, phase_1.nextConnectCommand)(phase, {
+        email: meta?.email,
+        phoneE164: meta?.phoneE164,
+    }) ?? exports.INTERACTIVE_CONNECT_COMMAND);
+}
+//# sourceMappingURL=incomplete-setup.js.map