create-mn-app 0.3.28 → 0.4.1

package/templates/hello-world/src/network.ts

@@ -0,0 +1,320 @@
+// This module is structured to be extracted into a standalone package
+// (@midnight-ntwrk/dapp-network or similar) without code changes. Do not
+// introduce template substitutions, sibling-template imports, or globals
+// here. All side-effecting inputs flow through function parameters.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+
+export type NetworkId = 'undeployed' | 'preview' | 'preprod';
+
+export const NETWORK_IDS: readonly NetworkId[] = ['undeployed', 'preview', 'preprod'] as const;
+
+export interface NetworkConfig {
+  networkId: NetworkId;
+  indexer: string;
+  indexerWS: string;
+  node: string;
+  proofServer: string;
+  faucet: string | null;
+  composeServices: string[];
+}
+
+export interface DeploymentRecord {
+  address: string;
+  deployedAt: string;
+  deployer: string;
+}
+
+export interface NetworkState {
+  version: 1;
+  activeNetwork: NetworkId;
+  wallets: Partial<Record<NetworkId, { seed: string; createdAt: string }>>;
+  deployments: Partial<Record<NetworkId, DeploymentRecord>>;
+}
+
+export const STATE_FILE_NAME = '.midnight-state.json';
+export const STATE_VERSION = 1 as const;
+
+export const NETWORK_CONFIGS: Record<NetworkId, NetworkConfig> = {
+  undeployed: {
+    networkId: 'undeployed',
+    indexer:   'http://127.0.0.1:8088/api/v4/graphql',
+    indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+    node:      'ws://127.0.0.1:9944',
+    proofServer: 'http://127.0.0.1:6300',
+    faucet: null,
+    composeServices: ['node', 'indexer', 'proof-server'],
+  },
+  preview: {
+    networkId: 'preview',
+    indexer:   'https://indexer.preview.midnight.network/api/v4/graphql',
+    indexerWS: 'wss://indexer.preview.midnight.network/api/v4/graphql/ws',
+    node:      'https://rpc.preview.midnight.network',
+    proofServer: 'http://127.0.0.1:6300',
+    faucet: 'https://faucet.preview.midnight.network',
+    composeServices: ['proof-server'],
+  },
+  preprod: {
+    networkId: 'preprod',
+    indexer:   'https://indexer.preprod.midnight.network/api/v4/graphql',
+    indexerWS: 'wss://indexer.preprod.midnight.network/api/v4/graphql/ws',
+    node:      'https://rpc.preprod.midnight.network',
+    proofServer: 'http://127.0.0.1:6300',
+    faucet: 'https://faucet.preprod.midnight.network',
+    composeServices: ['proof-server'],
+  },
+};
+
+export function isNetworkId(v: unknown): v is NetworkId {
+  return typeof v === 'string' && (NETWORK_IDS as readonly string[]).includes(v);
+}
+
+export interface FsOptions {
+  cwd?: string;
+}
+
+function statePath(opts: FsOptions = {}): string {
+  return path.join(opts.cwd ?? process.cwd(), STATE_FILE_NAME);
+}
+
+export function loadState(opts: FsOptions = {}): NetworkState | null {
+  const p = statePath(opts);
+  if (!fs.existsSync(p)) return null;
+  const raw = fs.readFileSync(p, 'utf-8');
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`Failed to parse ${p}: ${(e as Error).message}. Run \`npm run clean\` to reset.`);
+  }
+  if (
+    !parsed ||
+    typeof parsed !== 'object' ||
+    (parsed as { version?: unknown }).version !== STATE_VERSION
+  ) {
+    throw new Error(
+      `Unsupported state-file version in ${p} (expected ${STATE_VERSION}). Run \`npm run clean\` to reset.`,
+    );
+  }
+  if (!isNetworkId((parsed as { activeNetwork?: unknown }).activeNetwork)) {
+    throw new Error(
+      `Invalid activeNetwork in ${p}. Run \`npm run clean\` to reset.`,
+    );
+  }
+  return parsed as NetworkState;
+}
+
+export function saveState(state: NetworkState, opts: FsOptions = {}): void {
+  const p = statePath(opts);
+  // Write to a sibling tmp file then rename → atomic on POSIX.
+  const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+  fs.renameSync(tmp, p);
+}
+
+export function parseNetworkFlag(argv: string[]): NetworkId | null {
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--network') {
+      const v = argv[i + 1];
+      if (v === undefined) throw new Error('--network requires a value');
+      if (!isNetworkId(v)) {
+        throw new Error(`Unknown network: ${v}. Supported: ${NETWORK_IDS.join(', ')}.`);
+      }
+      return v;
+    }
+    if (arg.startsWith('--network=')) {
+      const v = arg.slice('--network='.length);
+      if (!isNetworkId(v)) {
+        throw new Error(`Unknown network: ${v}. Supported: ${NETWORK_IDS.join(', ')}.`);
+      }
+      return v;
+    }
+  }
+  return null;
+}
+
+export interface ResolveOptions {
+  argv?: string[];
+  env?: NodeJS.ProcessEnv;
+  cwd?: string;
+}
+
+export type ResolveSource = 'flag' | 'state' | 'default';
+
+export interface ResolveResult {
+  network: NetworkId;
+  config: NetworkConfig;
+  source: ResolveSource;
+}
+
+const ENV_OVERRIDES: Array<[keyof NetworkConfig, string]> = [
+  ['indexer', 'MIDNIGHT_INDEXER_URL'],
+  ['indexerWS', 'MIDNIGHT_INDEXER_WS_URL'],
+  ['node', 'MIDNIGHT_NODE_URL'],
+  ['faucet', 'MIDNIGHT_FAUCET_URL'],
+  ['proofServer', 'MIDNIGHT_PROOF_SERVER_URL'],
+];
+
+function applyEnvOverrides(base: NetworkConfig, env: NodeJS.ProcessEnv): NetworkConfig {
+  const out: NetworkConfig = { ...base, composeServices: [...base.composeServices] };
+  for (const [field, varName] of ENV_OVERRIDES) {
+    const v = env[varName];
+    if (v) (out as unknown as Record<string, unknown>)[field] = v;
+  }
+  return out;
+}
+
+export function resolveNetwork(opts: ResolveOptions = {}): ResolveResult {
+  const argv = opts.argv ?? process.argv;
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+
+  const flag = parseNetworkFlag(argv);
+  let network: NetworkId;
+  let source: ResolveSource;
+
+  if (flag) {
+    network = flag;
+    source = 'flag';
+  } else {
+    const state = loadState({ cwd });
+    if (state) {
+      network = state.activeNetwork;
+      source = 'state';
+    } else {
+      network = 'undeployed';
+      source = 'default';
+    }
+  }
+
+  const config = applyEnvOverrides(NETWORK_CONFIGS[network], env);
+  return { network, config, source };
+}
+
+export const GENESIS_SEED = '0000000000000000000000000000000000000000000000000000000000000001';
+
+export interface SeedOptions {
+  env?: NodeJS.ProcessEnv;
+  cwd?: string;
+}
+
+export function getOrCreateSeed(network: NetworkId, opts: SeedOptions = {}): string {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+
+  if (network === 'undeployed') return GENESIS_SEED;
+
+  const fromEnv = env.MIDNIGHT_WALLET_SEED;
+  if (fromEnv) return fromEnv;
+
+  const existing = loadState({ cwd });
+  const persisted = existing?.wallets?.[network]?.seed;
+  if (persisted) return persisted;
+
+  const seed = crypto.randomBytes(32).toString('hex');
+  const next: NetworkState = existing ?? {
+    version: STATE_VERSION,
+    activeNetwork: network,
+    wallets: {},
+    deployments: {},
+  };
+  next.activeNetwork = network;
+  next.wallets = {
+    ...next.wallets,
+    [network]: { seed, createdAt: new Date().toISOString() },
+  };
+  saveState(next, { cwd });
+  return seed;
+}
+
+export function getDeployment(network: NetworkId, opts: FsOptions = {}): DeploymentRecord | null {
+  const state = loadState(opts);
+  return state?.deployments?.[network] ?? null;
+}
+
+export function recordDeployment(
+  network: NetworkId,
+  address: string,
+  deployer: string,
+  opts: FsOptions = {},
+): void {
+  const cwd = opts.cwd ?? process.cwd();
+  const existing = loadState({ cwd });
+  const next: NetworkState = existing ?? {
+    version: STATE_VERSION,
+    activeNetwork: network,
+    wallets: {},
+    deployments: {},
+  };
+  next.deployments = {
+    ...next.deployments,
+    [network]: { address, deployer, deployedAt: new Date().toISOString() },
+  };
+  saveState(next, { cwd });
+}
+
+export function setActiveNetwork(network: NetworkId, opts: FsOptions = {}): void {
+  const cwd = opts.cwd ?? process.cwd();
+  const existing = loadState({ cwd });
+  if (existing && existing.activeNetwork === network) return; // no-op
+  const next: NetworkState = existing ?? {
+    version: STATE_VERSION,
+    activeNetwork: network,
+    wallets: {},
+    deployments: {},
+  };
+  next.activeNetwork = network;
+  saveState(next, { cwd });
+}
+
+// CLI entry point. Activates only when the file is run directly via tsx,
+// not when imported. Keeps the module tree-shakeable for the future
+// extracted package.
+function isMain(): boolean {
+  // import.meta.url is a `file://` URL; argv[1] is a filesystem path.
+  // Compare resolved paths to handle symlinks/aliases.
+  try {
+    const here = new URL(import.meta.url).pathname;
+    const invoked = process.argv[1] && fs.realpathSync(process.argv[1]);
+    return invoked === fs.realpathSync(here);
+  } catch {
+    return false;
+  }
+}
+
+function cliMain(argv: string[]): number {
+  const args = argv.slice(2);
+  if (args.length === 0) {
+    const r = resolveNetwork({ argv });
+    const dep = getDeployment(r.network);
+    process.stdout.write(`Active network: ${r.network}${r.source === 'default' ? ' (default)' : ''}\n`);
+    if (dep) process.stdout.write(`Last deploy: ${dep.address}\n`);
+    return 0;
+  }
+  const candidate = args[0];
+  if (!isNetworkId(candidate)) {
+    process.stderr.write(`Unknown network: ${candidate}. Supported: ${NETWORK_IDS.join(', ')}.\n`);
+    return 1;
+  }
+  setActiveNetwork(candidate);
+  process.stdout.write(`Active network is now: ${candidate}\n`);
+  if (candidate !== 'undeployed') {
+    const seed = loadState()?.wallets?.[candidate]?.seed;
+    if (!seed) {
+      process.stdout.write(`Wallet not yet generated — run \`npm run setup\` to fund and deploy.\n`);
+    }
+  }
+  return 0;
+}
+
+if (isMain()) {
+  try {
+    process.exit(cliMain(process.argv));
+  } catch (e) {
+    process.stderr.write(`${(e as Error).message}\n`);
+    process.exit(1);
+  }
+}

package/templates/hello-world/src/setup.ts.template

@@ -0,0 +1,37 @@
+// Orchestrator for `npm run setup`. Replaces the prior package.json chain
+// `docker compose up -d --wait && npm run compile && npm run deploy` so
+// we can branch on --network and forward it to deploy.
+import { spawnSync } from 'node:child_process';
+import { resolveNetwork, setActiveNetwork, parseNetworkFlag } from './network';
+
+function run(cmd: string, args: string[]): void {
+  const r = spawnSync(cmd, args, { stdio: 'inherit', shell: false });
+  if (r.status !== 0) {
+    process.stderr.write(`\nCommand failed: ${cmd} ${args.join(' ')}\n`);
+    process.exit(r.status ?? 1);
+  }
+}
+
+async function main(): Promise<void> {
+  const argv = process.argv;
+  const flag = parseNetworkFlag(argv);
+  if (flag) setActiveNetwork(flag);
+  const { network, config } = resolveNetwork({ argv });
+
+  process.stdout.write(`\n→ Setting up {{projectName}} on network: ${network}\n\n`);
+
+  // 1. Bring up only the services this network needs.
+  run('docker', ['compose', 'up', '-d', '--wait', ...config.composeServices]);
+
+  // 2. Compile the contract (network-agnostic).
+  run('npm', ['run', 'compile']);
+
+  // 3. Deploy. Forward --network so deploy.ts sees the same network.
+  const deployArgs = network === 'undeployed' ? [] : ['--', '--network', network];
+  run('npm', ['run', 'deploy', ...deployArgs]);
+}
+
+main().catch((e) => {
+  process.stderr.write(`\nSetup failed: ${(e as Error).message}\n`);
+  process.exit(1);
+});

package/templates/hello-world/src/wallet-state.ts

@@ -0,0 +1,95 @@
+// Wallet sync-state persistence.
+//
+// Mirrors network.ts: no template substitutions, all I/O via function
+// parameters, no SDK imports — keeps the module unit-testable from the
+// create-mn-app workspace (which doesn't install @midnight-ntwrk/* packages).
+//
+// Why: without persistence, every `npm run deploy` / `npm run cli` rebuilds
+// each child wallet from seed and re-syncs against the chain. On public
+// networks (preview, preprod) that's minutes per run — and painful on retries
+// after a transient failure. The SDK exposes serializeState() and restore()
+// on each child wallet class; wallet.ts is the glue that uses them, and this
+// file is the on-disk format underneath.
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import type { NetworkId } from './network';
+
+export const WALLET_STATE_DIR = '.midnight-wallet-state';
+export const WALLET_STATE_VERSION = 1 as const;
+
+export type ChildKind = 'shielded' | 'unshielded' | 'dust';
+export const CHILD_KINDS: readonly ChildKind[] = ['shielded', 'unshielded', 'dust'] as const;
+
+export interface PersistedWalletState {
+  shielded?: unknown;
+  unshielded?: unknown;
+  dust?: string;
+}
+
+export interface FsOptions {
+  cwd?: string;
+}
+
+function networkDir(network: NetworkId, opts: FsOptions = {}): string {
+  return path.join(opts.cwd ?? process.cwd(), WALLET_STATE_DIR, network);
+}
+
+function statePath(network: NetworkId, kind: ChildKind, opts: FsOptions = {}): string {
+  return path.join(networkDir(network, opts), `${kind}.json`);
+}
+
+function atomicWrite(file: string, content: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmp, content);
+  fs.renameSync(tmp, file);
+}
+
+interface VersionedState<T> {
+  version: typeof WALLET_STATE_VERSION;
+  state: T;
+}
+
+function readVersionedState<T>(file: string): T | undefined {
+  if (!fs.existsSync(file)) return undefined;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8')) as VersionedState<T>;
+    if (!parsed || typeof parsed !== 'object' || parsed.version !== WALLET_STATE_VERSION) {
+      return undefined;
+    }
+    return parsed.state;
+  } catch {
+    // Corrupt file — caller falls back to from-seed sync; we'll overwrite on save.
+    return undefined;
+  }
+}
+
+function writeVersionedState<T>(file: string, state: T): void {
+  const payload: VersionedState<T> = { version: WALLET_STATE_VERSION, state };
+  atomicWrite(file, `${JSON.stringify(payload)}\n`);
+}
+
+export function loadWalletState(network: NetworkId, opts: FsOptions = {}): PersistedWalletState {
+  return {
+    shielded: readVersionedState(statePath(network, 'shielded', opts)),
+    unshielded: readVersionedState(statePath(network, 'unshielded', opts)),
+    dust: readVersionedState<string>(statePath(network, 'dust', opts)),
+  };
+}
+
+export function saveWalletState(
+  network: NetworkId,
+  state: PersistedWalletState,
+  opts: FsOptions = {},
+): void {
+  if (state.shielded !== undefined) writeVersionedState(statePath(network, 'shielded', opts), state.shielded);
+  if (state.unshielded !== undefined) writeVersionedState(statePath(network, 'unshielded', opts), state.unshielded);
+  if (state.dust !== undefined) writeVersionedState(statePath(network, 'dust', opts), state.dust);
+}
+
+export function clearWalletState(network: NetworkId, opts: FsOptions = {}): void {
+  const dir = networkDir(network, opts);
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true });
+}

package/templates/hello-world/src/wallet.ts

@@ -0,0 +1,189 @@
+// Wallet construction + sync-state restore.
+//
+// Mirrors network.ts in structure. The on-disk format and pure I/O live in
+// wallet-state.ts (unit-tested from the scaffolder workspace, no SDK deps);
+// this file is the glue between that format and the wallet SDK.
+
+import { Buffer } from 'buffer';
+
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { unshieldedToken } from '@midnight-ntwrk/ledger-v8';
+import { setNetworkId, getNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
+import { DustWallet } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+import { HDWallet, Roles } from '@midnight-ntwrk/wallet-sdk-hd';
+import { ShieldedWallet } from '@midnight-ntwrk/wallet-sdk-shielded';
+import {
+  createKeystore,
+  NoOpTransactionHistoryStorage,
+  PublicKey,
+  UnshieldedWallet,
+} from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
+
+import type { NetworkConfig, NetworkId } from './network';
+import {
+  CHILD_KINDS,
+  loadWalletState,
+  saveWalletState,
+  type ChildKind,
+  type PersistedWalletState,
+} from './wallet-state';
+
+export { unshieldedToken };
+export type { PersistedWalletState };
+export {
+  loadWalletState,
+  saveWalletState,
+  clearWalletState,
+  WALLET_STATE_DIR,
+  WALLET_STATE_VERSION,
+} from './wallet-state';
+
+function deriveKeys(seed: string) {
+  const hdWallet = HDWallet.fromSeed(Buffer.from(seed, 'hex'));
+  if (hdWallet.type !== 'seedOk') throw new Error('Invalid seed');
+  const result = hdWallet.hdWallet
+    .selectAccount(0)
+    .selectRoles([Roles.Zswap, Roles.NightExternal, Roles.Dust])
+    .deriveKeysAt(0);
+  if (result.type !== 'keysDerived') throw new Error('Key derivation failed');
+  hdWallet.hdWallet.clear();
+  return result.keys;
+}
+
+export interface WalletContext {
+  wallet: Awaited<ReturnType<typeof WalletFacade.init>>;
+  shieldedSecretKeys: ReturnType<typeof ledger.ZswapSecretKeys.fromSeed>;
+  dustSecretKey: ReturnType<typeof ledger.DustSecretKey.fromSeed>;
+  unshieldedKeystore: ReturnType<typeof createKeystore>;
+  restored: { shielded: boolean; unshielded: boolean; dust: boolean };
+}
+
+export interface CreateWalletOptions {
+  network: NetworkId;
+  networkConfig: NetworkConfig;
+  seed: string;
+  /**
+   * Whether to attempt to restore each child wallet from saved state.
+   * Defaults to true. Pass false to force a from-seed sync (used by tests).
+   */
+  restore?: boolean;
+  cwd?: string;
+}
+
+function warnRestoreFailure(kind: ChildKind, err: unknown): void {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`  ⚠ Could not restore ${kind} wallet state (${msg}); falling back to fresh sync.\n`);
+}
+
+/**
+ * Build the wallet facade, restoring each child from saved state when
+ * available and falling back to a from-seed start when not (or when restore
+ * throws, e.g. after an SDK upgrade with an incompatible state format).
+ *
+ * Caller is responsible for `await wallet.waitForSyncedState()` afterwards.
+ */
+export async function createWallet(opts: CreateWalletOptions): Promise<WalletContext> {
+  setNetworkId(opts.networkConfig.networkId);
+
+  const keys = deriveKeys(opts.seed);
+  const networkId = getNetworkId();
+  const shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(keys[Roles.Zswap]);
+  const dustSecretKey = ledger.DustSecretKey.fromSeed(keys[Roles.Dust]);
+  const unshieldedKeystore = createKeystore(keys[Roles.NightExternal], networkId);
+
+  const saved: PersistedWalletState = opts.restore === false
+    ? {}
+    : loadWalletState(opts.network, { cwd: opts.cwd });
+
+  const restored = { shielded: false, unshielded: false, dust: false };
+
+  const walletConfig = {
+    networkId,
+    indexerClientConnection: {
+      indexerHttpUrl: opts.networkConfig.indexer,
+      indexerWsUrl: opts.networkConfig.indexerWS,
+    },
+    provingServerUrl: new URL(opts.networkConfig.proofServer),
+    relayURL: new URL(opts.networkConfig.node.replace(/^http/, 'ws')),
+    txHistoryStorage: new NoOpTransactionHistoryStorage(),
+    costParameters: { additionalFeeOverhead: 300_000_000_000_000n, feeBlocksMargin: 5 },
+  };
+
+  const wallet = await WalletFacade.init({
+    configuration: walletConfig,
+    shielded: async (config) => {
+      const cls = ShieldedWallet(config);
+      if (saved.shielded !== undefined) {
+        try {
+          const restoredWallet = await (cls as any).restore(saved.shielded);
+          restored.shielded = true;
+          return restoredWallet;
+        } catch (err) {
+          warnRestoreFailure('shielded', err);
+        }
+      }
+      return cls.startWithSecretKeys(shieldedSecretKeys);
+    },
+    unshielded: async (config) => {
+      const cls = UnshieldedWallet(config);
+      if (saved.unshielded !== undefined) {
+        try {
+          const restoredWallet = await (cls as any).restore(saved.unshielded);
+          restored.unshielded = true;
+          return restoredWallet;
+        } catch (err) {
+          warnRestoreFailure('unshielded', err);
+        }
+      }
+      return cls.startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore));
+    },
+    dust: async (config) => {
+      const cls = DustWallet(config);
+      if (saved.dust !== undefined) {
+        try {
+          const restoredWallet = await (cls as any).restore(saved.dust);
+          restored.dust = true;
+          return restoredWallet;
+        } catch (err) {
+          warnRestoreFailure('dust', err);
+        }
+      }
+      return cls.startWithSecretKey(dustSecretKey, ledger.LedgerParameters.initialParameters().dust);
+    },
+  });
+
+  await wallet.start(shieldedSecretKeys, dustSecretKey);
+
+  return { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore, restored };
+}
+
+/**
+ * Serialize each child wallet's current state and persist it for the next run.
+ * Safe to call multiple times. Logs but does not throw on individual failures —
+ * losing one child's state means the next run re-syncs that child only.
+ */
+export async function persistWalletState(
+  network: NetworkId,
+  ctx: WalletContext,
+  cwd?: string,
+): Promise<void> {
+  const next: PersistedWalletState = {};
+
+  for (const kind of CHILD_KINDS) {
+    try {
+      const child = (ctx.wallet as unknown as Record<ChildKind, { serializeState: () => Promise<unknown> }>)[kind];
+      const serialized = await child.serializeState();
+      if (kind === 'dust') {
+        next.dust = serialized as string;
+      } else {
+        next[kind] = serialized;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`  ⚠ Could not serialize ${kind} wallet state (${msg}); next run will re-sync.\n`);
+    }
+  }
+
+  saveWalletState(network, next, { cwd });
+}

package/templates/hello-world/tsconfig.json.template

@@ -2,7 +2,7 @@
   "compilerOptions": {
     "target": "ES2022",
     "module": "ESNext",
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,

package/dist/installers/wallet-generator.d.ts

@@ -1,4 +0,0 @@
-export declare class WalletGenerator {
-    generate(projectPath: string): Promise<string>;
-}
-//# sourceMappingURL=wallet-generator.d.ts.map

package/dist/installers/wallet-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wallet-generator.d.ts","sourceRoot":"","sources":["../../src/installers/wallet-generator.ts"],"names":[],"mappings":"AAmBA,qBAAa,eAAe;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAwDrD"}