neozip-cli 0.80.0 → 0.95.0

package/README.md

@@ -6,9 +6,9 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D16.0.0-brightgreen)](https://nodejs.org/)
 
-## ⚠️ Beta Release Notice
+## Release Notice
 
-**This is a beta release (v0.75.0-beta).** This software is in active development and may contain bugs or incomplete features. While more stable than alpha releases, please use with caution in production environments.
+**Current version: v0.90.0.** This release adds full AES-256 encryption support. See [CHANGELOG.md](CHANGELOG.md) for details.
 
 - **API Stability**: Command-line interface is becoming more stable but may still change
 - **Testing**: Please test thoroughly and report any issues
@@ -21,7 +21,7 @@ NeoZip CLI is a modern, full-featured ZIP utility that provides:
 - **Standard ZIP Compatibility**: ~99% compatible with InfoZip utilities
 - **Blockchain Integration**: Tokenize archives and verify integrity on-chain
 - **Advanced Compression**: Zstd, Deflate, and Store compression methods
-- **Encryption Support**: PKZIP encryption
+- **Encryption Support**: AES-256 (default) and PKZIP encryption
 - **Cross-Platform**: Works on macOS, Linux, and Windows
 
 ## Features
@@ -42,14 +42,15 @@ NeoZip CLI is a modern, full-featured ZIP utility that provides:
 - Compression levels: 0-9 (0=store, 9=best compression)
 
 ### Encryption
-- **PKZIP**: Legacy encryption (maximum compatibility)
+- **AES-256**: Strong encryption (default, recommended)
+- **PKZIP**: Legacy encryption (for compatibility only)
 - Password-protected archives
-- InfoZip-compatible encrypted archives
+- Auto-detection of encryption method during extraction
 
 ### Blockchain Features
 - **Tokenization**: Create on-chain tokens for archives
 - **OpenTimestamp**: Bitcoin blockchain timestamping
-- **Zipstamp**: Ethereum blockchain timestamping (Zipstamp server)
+- **Token Service**: Ethereum blockchain timestamping (NeoZip Token Service)
 - **Integrity Verification**: Verify archive integrity on-chain
 - **Network Support**: Base Sepolia, Base Mainnet, Arbitrum, and more
 
@@ -68,12 +69,13 @@ NeoZip CLI is a modern, full-featured ZIP utility that provides:
 ### Prerequisites
 
 - Node.js 16.0.0 or higher
-- npm or yarn package manager
+- [pnpm](https://pnpm.io/) 10+ (required for development from source)
+- npm (optional — for global install of the published package only)
 
-### Install from npm (Beta Release)
+### Install from npm
 
 ```bash
-npm install -g neozip-cli@beta
+npm install -g neozip-cli
 ```
 
 After installation, the following commands will be available:
@@ -138,13 +140,19 @@ neozip -0 output.nzip ./src/
 ### Encryption Examples
 
 ```bash
-# Create encrypted archive (will prompt for password)
+# Create AES-256 encrypted archive (default, will prompt for password)
 neozip -e secure.nzip file.txt
 
-# Create encrypted archive with password
+# Create AES-256 encrypted archive with password
 neozip -e -P "mypassword" secure.nzip file.txt
 
-# Extract encrypted archive
+# Explicitly use AES-256
+neozip --aes256 -P "mypassword" secure.nzip file.txt
+
+# Use legacy PKZIP encryption (weak, for compatibility only)
+neozip --pkzip -P "mypassword" legacy.nzip file.txt
+
+# Extract encrypted archive (auto-detects AES-256 or PKZIP)
 neounzip -P "mypassword" secure.nzip tests/extracted/
 ```
 
@@ -157,11 +165,11 @@ neozip -b tokenized.nzip file.txt
 # Tokenize with OpenTimestamp proof (Bitcoin)
 neozip -ots timestamped.nzip file.txt
 
-# Create Zipstamp timestamp (Ethereum)
-neozip -ts zipstamp.nzip file.txt
+# Create Token Service timestamp (Ethereum)
+neozip -ts timestamped.nzip file.txt
 
-# Upgrade pending Zipstamp timestamp to confirmed
-neozip upgrade zipstamp.nzip [output.nzip] [--wait]
+# Upgrade pending Token Service timestamp to confirmed
+neozip upgrade timestamped.nzip [output.nzip] [--wait]
 
 # Extract and verify blockchain integrity
 neounzip tokenized.nzip tests/extracted/
@@ -183,21 +191,22 @@ neozip [options] <archive> [files...]
 - `-0` to `-9` - Compression level (0=store, 9=best)
 - `-x, --exclude <pattern>` - Exclude files matching pattern
 - `-i, --include <pattern>` - Include only matching files
-- `-e, --encrypt` - Encrypt files (will prompt for password)
+- `-e, --encrypt` - Encrypt files with AES-256 (default, will prompt for password)
 - `-P, --password <pwd>` - Encrypt with password
+- `--aes256` - Use AES-256 encryption (default, recommended)
+- `--pkzip` - Use legacy PKZIP encryption (weak, for compatibility only)
 - `-b, --blockchain` - Enable blockchain tokenization
 - `-ots, --opentimestamp` - Enable OpenTimestamp proof (Bitcoin)
-- `-ts, --timestamp` - Enable Zipstamp timestamp (Ethereum)
-- `--timestamp-email <email>` - Email for Zipstamp server (some servers require verified email)
+- `-ts, --timestamp` - Enable Token Service timestamp (Ethereum; requires `neozip connect`)
 - `-T, --test-integrity` - Test archive after creation
 - `-v, --verbose` - Enable verbose output
 - `-q, --quiet` - Suppress output
 
 **Configuration Commands:**
 ```bash
-neozip init      # Interactive wallet setup wizard
-neozip config    # Show current configuration
-neozip upgrade <archive> [output] [--wait]  # Upgrade pending Zipstamp timestamp to confirmed
+neozip connect   # Token Service account + wallet setup (alias: neozip init)
+neozip config    # Connection dashboard (status, prefs, migrate)
+neozip upgrade <archive> [output] [--wait]  # Upgrade pending Token Service timestamp to confirmed
 ```
 
 **Examples:**
@@ -232,7 +241,7 @@ neounzip [options] <archive> [output]
 - `-o, --overwrite` - Overwrite files without prompting
 - `-t, --test` - Test archive integrity
 - `-l, --list` - List contents without extracting
-- `-P, --password <pwd>` - Password for encrypted archives
+- `-P, --password <pwd>` - Password for encrypted archives (AES-256 and PKZIP auto-detected)
 - `-x, --exclude <pattern>` - Exclude files from extraction
 - `-i, --include <pattern>` - Include only matching files
 - `-j, --junk-paths` - Extract files without directory structure
@@ -292,41 +301,26 @@ neolist -1 archive.nzip
 
 ## Configuration
 
-### Wallet Setup (for Blockchain Features)
+### Account and wallet setup
 
-To use blockchain features, you need to configure a wallet:
+All wallet identity and Token Service credentials live in the shared connection store (`~/.neozip/connection/`). Use the same profile as NeoZip Desktop and MCP.
 
 ```bash
-# Interactive setup wizard
-neozip init
+neozip connect          # Interactive setup (alias: neozip init)
+neozip connect status   # Show connection phase and credentials
+neozip connect settings # Default network, RPC overrides, gas prefs
+neozip connect migrate  # Import legacy wallet.json / MCP profiles
+neozip config           # Connection dashboard (status, prefs, migrate)
 ```
 
-This will guide you through:
-1. Creating or importing a wallet
-2. Selecting a blockchain network
-3. Saving configuration to `~/.neozip/wallet.json`
+On-chain preferences (`defaultNetwork`, custom RPC URLs, gas) are stored in each connection's `public.json`.
 
-### Environment Variables
-
-You can also configure via environment variables:
+Optional overrides:
 
 ```bash
-export NEOZIP_WALLET_PASSKEY="your-wallet-key"
-export NEOZIP_NETWORK="base-sepolia"  # or base-mainnet, arbitrum-sepolia, etc.
-export ZIPSTAMP_SERVER_URL="https://zipstamp-dev.neozip.io"  # Zipstamp server (optional)
-export NEOZIP_TIMESTAMP_EMAIL="your@email.com"  # Email for Zipstamp (some servers require verified email)
-```
-
-### Configuration File
-
-Configuration is stored in `~/.neozip/wallet.json`:
-
-```json
-{
-  "walletKey": "0x...",
-  "network": "base-sepolia",
-  "rpcUrl": "https://..."
-}
+export NEOZIP_CONNECTION_DIR="/path/to/connection"  # Store path override
+export NEOZIP_UNLOCK_PASSPHRASE="..."               # Decrypt secrets.enc non-interactively
+export NEOZIP_NETWORK="base-sepolia"                # Override default network for this session
 ```
 
 ## Advanced Examples
@@ -376,10 +370,13 @@ neozip -r -x "node_modules" -x "*.log" project.nzip ./
 ### Encryption
 
 ```bash
-# Create encrypted archive
+# Create AES-256 encrypted archive (default)
 neozip -e -P "secure-password" secret.nzip sensitive-files/
 
-# Extract encrypted archive
+# Create legacy PKZIP encrypted archive
+neozip --pkzip -P "secure-password" legacy.nzip sensitive-files/
+
+# Extract encrypted archive (auto-detects encryption method)
 neounzip -P "secure-password" secret.nzip decrypted/
 ```
 
@@ -415,6 +412,73 @@ neozip -X archive.nzip ./files/
 neozip -y archive.nzip ./symlinks/
 ```
 
+## For AI agents
+
+NeoZip ships an agent-friendly surface. See [AGENTS.md](AGENTS.md) and the
+[skills/](skills/) directory for the full guide.
+
+### Install Agent Skills
+
+Six bundled skills (`neozip-shared`, `neozip-create`, `neozip-extract`, `neozip-list`,
+`neozip-connect`, `neozip-legacy`) ship inside the npm package. Install them into
+Claude Code or Cursor after `npm install -g neozip-cli`:
+
+```bash
+# Symlink bundled skills into ~/.claude/skills and ~/.cursor/skills
+neozip skills install
+
+# Claude Code only
+neozip skills install --target claude
+
+# Show where skills live in your install
+neozip skills path
+neozip skills list
+
+# ZIP files for Claude Cowork / claude.ai upload (Customize > Skills)
+neozip skills pack --output-dir ./neozip-skills-zips
+```
+
+Alternative (skills registry, same format as Google Workspace CLI):
+
+```bash
+npx skills add https://github.com/NeoWareInc/neozip-cli
+npx skills add https://github.com/NeoWareInc/neozip-cli/tree/main/skills/neozip-create
+```
+
+### CLI conventions
+
+- **Machine-readable output:** add `--format json` to any command to get a
+  single JSON object on stdout (`{ "ok": true, ... }` or
+  `{ "ok": false, "error": { ... } }`). Human hints go to stderr.
+- **JSON input:** `--params '<JSON>'` (options) and `--json '<JSON>'` (payload:
+  archive + files/targets). Either accepts `-` to read from stdin. Explicit CLI
+  flags override JSON input.
+- **Schema introspection:** `neozip schema <neozip|neounzip|neolist|connect>`
+  emits the accepted fields, types, defaults, and exit codes.
+- **Dry-run:** `neozip`/`neounzip` accept `--dry-run` to resolve and print the
+  plan as JSON without writing anything.
+- **Safety:** archive names and extraction dirs are validated for control
+  characters; `neounzip` refuses zip-slip (entries escaping the target dir).
+- **Exit codes:** InfoZip-compatible and echoed in `error.exitCode`.
+
+```bash
+# Introspect, then create fully from JSON
+neozip schema neozip
+neozip --format json \
+  --params '{"level":9,"encrypt":true,"password":"s3cret"}' \
+  --json '{"archive":"out.zip","files":["src/","README.md"]}'
+
+# Preview an extraction, then run it
+neounzip --format json --dry-run --params '{"exdir":"out"}' in.zip
+neounzip --format json --params '{"exdir":"out","overwrite":true}' in.zip
+
+# List as JSON
+neolist --format json in.zip
+```
+
+For an archive that stock InfoZip `unzip` can read, add `--legacy` (forces
+deflate/store + PKZIP, disables NeoZip extensions).
+
 ## Requirements
 
 - **Node.js**: 16.0.0 or higher
@@ -467,11 +531,11 @@ neozip new-archive.nzip original-files/
 
 **Blockchain errors:**
 ```bash
-# Check wallet configuration
-neozip config
+# Check connection status
+neozip connect status
 
-# Reconfigure wallet
-neozip init
+# Re-run setup
+neozip connect
 ```
 
 **Encryption errors:**
@@ -479,19 +543,29 @@ neozip init
 # Verify password is correct
 neounzip -P "your-password" archive.nzip
 
-# Try different encryption method
-neozip --pkzip-encrypt -P "password" archive.nzip files/
+# Use legacy PKZIP if AES-256 is not supported by target tool
+neozip --pkzip -P "password" archive.nzip files/
 ```
 
 ## Contributing
 
-We welcome feedback and contributions! Since this is a beta release, we're actively seeking input:
+We welcome feedback and contributions:
 
 1. **Report Issues**: Use [GitHub Issues](https://github.com/NeoWareInc/neozip-support/issues) or email [support@neozip.io](mailto:support@neozip.io)
 2. **Suggest Features**: Share your ideas and use cases
 3. **Test and Provide Feedback**: Help us improve by testing and reporting your experience
 
-**Important**: This is a beta release. API and behavior may still change. Please test thoroughly.
+### Development setup
+
+Requires [pnpm](https://pnpm.io/) (`packageManager: pnpm@10.12.1`):
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+```
+
+**Important**: Please test thoroughly and report issues. See [CHANGELOG.md](CHANGELOG.md) for version history.
 
 ## License
 
@@ -511,6 +585,6 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ---
 
-**Version**: 0.75.0-beta  
-**Status**: Beta Release  
-**Last Updated**: December 26, 2025
+**Version**: 0.90.0
+**Status**: Release (see [CHANGELOG.md](CHANGELOG.md) for latest changes)
+**Last Updated**: March 18, 2026

package/dist/src/account/account-state.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAccountPhase = computeAccountPhase;
+exports.buildAccountStatusReport = buildAccountStatusReport;
+const token_service_1 = require("neozip-blockchain/token-service");
+const mask_1 = require("../util/mask");
+const profile_store_1 = require("./profile-store");
+const token_auth_1 = require("../connection/token-auth");
+function nextStepsForPhase(phase) {
+    switch (phase) {
+        case "no_profile":
+            return (0, profile_store_1.listProfiles)().length > 0
+                ? ["account_select", "account_list", "account_create"]
+                : ["account_create", "account_list"];
+        case "email_unverified":
+            return ["account_register_email", "account_verify_email"];
+        case "no_wallet":
+            return ["account_create_wallet", "account_import_wallet"];
+        case "wallet_unlinked":
+            return ["account_link_wallet"];
+        case "identity_missing":
+            return ["account_provision_identity"];
+        case "ready":
+            return ["account_logout"];
+        case "degraded":
+            return ["account_status"];
+        default:
+            return ["account_status"];
+    }
+}
+function computeAccountPhase() {
+    const profileId = (0, profile_store_1.getActiveProfileId)();
+    if (!profileId) {
+        return "no_profile";
+    }
+    const profile = (0, profile_store_1.getActiveProfile)();
+    const secrets = (0, profile_store_1.readActiveSecrets)();
+    if (!profile || !secrets)
+        return "no_profile";
+    if (!secrets.accessToken || !profile.emailVerified) {
+        return "email_unverified";
+    }
+    if (!secrets.evmPrivateKey || !profile.evmAddress) {
+        return "no_wallet";
+    }
+    if (!profile.walletId || profile.linkId == null) {
+        return "wallet_unlinked";
+    }
+    if (!profile.identityKeyId) {
+        return "identity_missing";
+    }
+    return "ready";
+}
+async function buildAccountStatusReport(options) {
+    const profile = (0, profile_store_1.getActiveProfile)();
+    const secrets = (0, profile_store_1.readActiveSecrets)();
+    const phase = computeAccountPhase();
+    const tokenExpiresAt = secrets?.accessTokenExpiresAt ?? null;
+    const tokenExpired = Boolean(secrets?.accessToken) && (0, token_auth_1.isAccessTokenExpired)(secrets);
+    const tokenServiceUrl = (0, token_service_1.getTokenServiceUrl)({
+        serverUrl: profile?.tokenServiceUrl || undefined,
+    });
+    let tokenServiceReachable = null;
+    if (options?.probeTokenService !== false) {
+        try {
+            tokenServiceReachable = await (0, token_service_1.fetchCoordinatorConfig)(tokenServiceUrl);
+        }
+        catch {
+            tokenServiceReachable = false;
+        }
+    }
+    const nextSteps = nextStepsForPhase(tokenServiceReachable === false && phase !== "ready" ? "degraded" : phase);
+    const reloadRequired = phase === "ready" &&
+        Boolean(profile &&
+            (!process.env.NEOZIP_TOKEN_SERVICE_ACCESS_TOKEN ||
+                !process.env.NEOZIP_WALLET_PASSKEY));
+    return {
+        success: true,
+        phase: tokenServiceReachable === false && phase !== "ready" ? "degraded" : phase,
+        activeProfileId: (0, profile_store_1.getActiveProfileId)(),
+        profile: profile
+            ? {
+                ...profile,
+                email: profile.email ? (0, mask_1.maskEmail)(profile.email) : null,
+            }
+            : null,
+        tokenServiceReachable,
+        tokenServiceUrl,
+        tokenExpiresAt,
+        tokenExpired,
+        nextSteps,
+        reloadRequired,
+    };
+}
+//# sourceMappingURL=account-state.js.map

package/dist/src/account/format-account-status.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAccountStatusText = formatAccountStatusText;
+function formatExpiry(expiresAt) {
+    const deltaMs = expiresAt - Date.now();
+    const abs = Math.abs(deltaMs);
+    const minutes = Math.round(abs / 60000);
+    const hours = Math.round(abs / 3600000);
+    const days = Math.round(abs / 86400000);
+    let rel;
+    if (abs < 3600000)
+        rel = `${minutes} min`;
+    else if (abs < 86400000)
+        rel = `${hours} hr`;
+    else
+        rel = `${days} day${days === 1 ? "" : "s"}`;
+    const when = new Date(expiresAt).toISOString();
+    return deltaMs >= 0 ? `in ${rel} (${when})` : `${rel} ago (${when})`;
+}
+function formatAccountStatusText(report) {
+    const lines = [];
+    lines.push("NeoZip account status");
+    lines.push(`Phase: ${report.phase}`);
+    lines.push(`Token Service: ${report.tokenServiceUrl}`);
+    if (report.tokenServiceReachable != null) {
+        lines.push(`Token Service reachable: ${report.tokenServiceReachable ? "yes" : "no"}`);
+    }
+    if (report.tokenExpired) {
+        lines.push("Access token: EXPIRED — run neozip connect refresh");
+    }
+    else if (report.tokenExpiresAt != null) {
+        lines.push(`Access token: valid (expires ${formatExpiry(report.tokenExpiresAt)})`);
+    }
+    if (report.activeProfileId) {
+        lines.push(`Active profile: ${report.activeProfileId}`);
+    }
+    if (report.profile) {
+        lines.push(`Label: ${report.profile.label}`);
+        if (report.profile.email)
+            lines.push(`Email: ${report.profile.email}`);
+        if (report.profile.evmAddress) {
+            lines.push(`EVM address: ${report.profile.evmAddress}`);
+        }
+        if (report.profile.walletId != null) {
+            lines.push(`Wallet ID: ${report.profile.walletId}`);
+        }
+        if (report.profile.identityKeyId != null) {
+            lines.push(`Identity key ID: ${report.profile.identityKeyId}`);
+        }
+        if (report.profile.x25519Fingerprint) {
+            lines.push(`X25519 fingerprint: ${report.profile.x25519Fingerprint}`);
+        }
+    }
+    if (report.nextSteps.length) {
+        lines.push(`Next steps: ${report.nextSteps.join(", ")}`);
+    }
+    if (report.reloadRequired) {
+        lines.push("Reload MCP in Cursor so the active connection credentials are loaded into this session.");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=format-account-status.js.map

package/dist/src/account/identity-provision.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provisionWalletIdentityKey = provisionWalletIdentityKey;
+exports.refreshIdentityFromCryptoSelf = refreshIdentityFromCryptoSelf;
+const identity_key_1 = require("../archive/identity-key");
+const crypto_self_1 = require("../archive/crypto-self");
+const identity_wrap_1 = require("./identity-wrap");
+const token_service_1 = require("neozip-blockchain/token-service");
+const wallet_evm_1 = require("./wallet-evm");
+async function provisionWalletIdentityKey(params) {
+    const existing = await (0, token_service_1.getIdentityKeyBundle)(params.baseUrl, params.accessToken, params.walletId);
+    if (existing.found) {
+        return {
+            identityKeyId: existing.identityKeyId,
+            x25519PublicKey: existing.x25519PublicKey,
+            provisioned: false,
+        };
+    }
+    const eoaPriv = (0, wallet_evm_1.rawEoaBytes)(params.evmPrivateKey);
+    try {
+        const wrap = (0, identity_wrap_1.wrapNewX25519Keypair)({
+            rawEoaPrivBytes: eoaPriv,
+            evmAddress: params.evmAddress,
+        });
+        const bundleBody = {
+            x25519PublicKeyB64: wrap.x25519PublicKeyB64,
+            ...wrap.bundle,
+        };
+        const challenge = await (0, token_service_1.requestIdentityKeyInitChallenge)(params.baseUrl, params.accessToken, params.walletId, bundleBody);
+        const expectedMessage = (0, identity_wrap_1.buildIdentityKeyInitMessage)({
+            walletId: params.walletId,
+            challengeId: challenge.challengeId,
+            evmAddress: params.evmAddress,
+            formatVersion: wrap.bundle.wrapFormatVersion,
+            x25519PublicKeyB64: wrap.x25519PublicKeyB64,
+            wrappedSha256Hex: wrap.wrappedSha256Hex,
+        });
+        if (challenge.message !== expectedMessage) {
+            throw new identity_key_1.IdentityKeyTamperError("Server init message does not match canonical form expected by this client.");
+        }
+        const evmSignature = await (0, wallet_evm_1.signEvmMessage)(params.evmPrivateKey, challenge.message);
+        try {
+            const completed = await (0, token_service_1.completeIdentityKeyInit)(params.baseUrl, params.accessToken, params.walletId, bundleBody, challenge.challengeId, evmSignature);
+            return {
+                identityKeyId: completed.identityKeyId,
+                x25519PublicKey: completed.x25519PublicKey,
+                provisioned: true,
+            };
+        }
+        catch (err) {
+            if (err instanceof token_service_1.IdentityKeyConflictError) {
+                const reloaded = await (0, token_service_1.getIdentityKeyBundle)(params.baseUrl, params.accessToken, params.walletId);
+                if (reloaded.found) {
+                    return {
+                        identityKeyId: reloaded.identityKeyId,
+                        x25519PublicKey: reloaded.x25519PublicKey,
+                        provisioned: false,
+                    };
+                }
+            }
+            throw err;
+        }
+    }
+    finally {
+        eoaPriv.fill(0);
+    }
+}
+/** Sync profile metadata with live /crypto/self when token is available. */
+async function refreshIdentityFromCryptoSelf(config) {
+    const self = await (0, crypto_self_1.fetchCryptoSelf)(config);
+    if (!self.ok) {
+        return { identityKeyId: null, walletId: null };
+    }
+    return {
+        identityKeyId: self.data.identityKeyId,
+        walletId: self.data.walletId,
+    };
+}
+//# sourceMappingURL=identity-provision.js.map

package/dist/src/account/identity-wrap.js

@@ -0,0 +1,106 @@
+"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.buildIdentityKeyInitMessage = buildIdentityKeyInitMessage;
+exports.wrapNewX25519Keypair = wrapNewX25519Keypair;
+const crypto = __importStar(require("node:crypto"));
+const wallet_identity_1 = require("../constants/wallet-identity");
+function buildCanonicalAad(params) {
+    const lowerAddr = params.evmAddress.toLowerCase();
+    const addrBytes = Buffer.from(lowerAddr, "ascii");
+    return Buffer.concat([
+        addrBytes,
+        Buffer.from([wallet_identity_1.WRAP_FORMAT_VERSION]),
+        params.x25519SpkiDer,
+    ]);
+}
+function deriveKek(rawEoaPrivBytes, saltB64) {
+    const salt = Buffer.from(saltB64, "base64");
+    if (salt.length !== wallet_identity_1.WRAP_KDF_SALT_LEN) {
+        throw new Error(`Wrap KDF salt must be ${wallet_identity_1.WRAP_KDF_SALT_LEN} bytes`);
+    }
+    return Buffer.from(crypto.hkdfSync("sha256", rawEoaPrivBytes, salt, wallet_identity_1.WRAP_KDF_INFO, 32));
+}
+function sha256Hex(buf) {
+    return crypto.createHash("sha256").update(buf).digest("hex");
+}
+function buildIdentityKeyInitMessage(params) {
+    return [
+        "NeoZip Token Service identity key init",
+        `walletId:${params.walletId}`,
+        `challenge:${params.challengeId}`,
+        `address:${params.evmAddress.toLowerCase()}`,
+        `formatVersion:${params.formatVersion}`,
+        `x25519:${params.x25519PublicKeyB64}`,
+        `wrappedSha256:${params.wrappedSha256Hex}`,
+    ].join("\n");
+}
+function wrapNewX25519Keypair(params) {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync("x25519");
+    const spkiDer = publicKey.export({ type: "spki", format: "der" });
+    const pkcs8Der = privateKey.export({ type: "pkcs8", format: "der" });
+    const rawPriv = pkcs8Der.subarray(pkcs8Der.length - 32);
+    const saltB64 = crypto.randomBytes(wallet_identity_1.WRAP_KDF_SALT_LEN).toString("base64");
+    const ivB64 = crypto.randomBytes(wallet_identity_1.WRAP_IV_LEN).toString("base64");
+    const aad = buildCanonicalAad({
+        evmAddress: params.evmAddress,
+        x25519SpkiDer: spkiDer,
+    });
+    const kek = deriveKek(params.rawEoaPrivBytes, saltB64);
+    const iv = Buffer.from(ivB64, "base64");
+    const cipher = crypto.createCipheriv("aes-256-gcm", kek, iv);
+    cipher.setAAD(aad);
+    const ct = Buffer.concat([cipher.update(rawPriv), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const wrapped = Buffer.concat([ct, tag]);
+    kek.fill(0);
+    rawPriv.fill(0);
+    pkcs8Der.fill(0);
+    const bundle = {
+        wrappedPrivateKeyB64: wrapped.toString("base64"),
+        wrapFormatVersion: wallet_identity_1.WRAP_FORMAT_VERSION,
+        wrapKdfInfo: wallet_identity_1.WRAP_KDF_INFO,
+        wrapKdfSaltB64: saltB64,
+        wrapAead: wallet_identity_1.WRAP_AEAD,
+        wrapIvB64: ivB64,
+        wrapAadB64: aad.toString("base64"),
+    };
+    return {
+        bundle,
+        x25519PublicKeyB64: spkiDer.toString("base64"),
+        wrappedSha256Hex: sha256Hex(wrapped),
+    };
+}
+//# sourceMappingURL=identity-wrap.js.map