Config & deployments

export interface NetworkDeployment {
	readonly network?: string;
	readonly rpc: string;
	readonly chainId?: string;
	readonly faucet?: string | null;
	readonly graphql?: string | null;
	/** Marks a live LOCAL network (a `devstack up` stack). Production builds
	 *  ship only non-local networks. */
	readonly local?: boolean;
	readonly packages: {
		readonly [name: string]: {
			readonly id: string;
			readonly objects?: { readonly [k: string]: string };
		};
	};
	readonly mvrOverrides: {
		readonly packages: { readonly [mvrPlaceholder: string]: string };
		readonly types: { readonly [namedType: string]: string };
	};
	/** Generic resolver channel: `values[namespace][key]` carries arbitrary
	 *  plugin JSON the typed fields above can't (deepbook pool ids, coin
	 *  types, walrus/seal endpoints). */
	readonly values?: { readonly [namespace: string]: { readonly [key: string]: unknown } };
}

export interface DevstackDeployment {
	readonly defaultNetwork: string;
	readonly networks: { readonly [name: string]: NetworkDeployment };
	/** DEV-only account name → address map. Network-agnostic (keypair gen
	 *  needs no network), so it lives on the envelope, NOT per-network. Only
	 *  present when running through devstack (dev serve); a real prod
	 *  deployment carries none. */
	readonly accounts?: { readonly [name: string]: string };
}

/** Exhaustive over THIS app's declared package names. */
export interface AppPackages {
	readonly connect_four: { readonly id: string; readonly objects?: Record<string, string> };
}

/** The per-network shape a prod author hand-writes in `deployments/<net>.ts`:
 *  a `NetworkDeployment` narrowed so `packages` is exhaustive over this app's
 *  packages, `mvrOverrides` is the @mysten MVR override surface
 *  (`{ packages, types }`) requiring every declared `@local/<slug>`
 *  placeholder, and `values` requires every service value namespace/key (when
 *  the app declares any). NO `accounts` — dev accounts ride the runtime
 *  envelope. */
export interface AppNetworkDeployment extends Omit<
	NetworkDeployment,
	'packages' | 'mvrOverrides' | 'values'
> {
	readonly packages: AppPackages;
	readonly mvrOverrides: {
		readonly packages: {
			'@local/connect-four': string;
		} & { readonly [mvrPlaceholder: string]: string };
		readonly types?: { readonly [namedType: string]: string };
	};
	readonly values?: NetworkDeployment['values'];
}

/** The LIVE network names this app ships — the `deployments/*.ts` filenames. */
export type ProvidedNetwork = 'devnet';

/** The committed per-network deployments map a prod build / dev serve loads. */
export type ProvidedDeployments = Partial<Record<ProvidedNetwork, AppNetworkDeployment>>;

/** The full network-name set, local-first: `[<local>, ...<provided>]`. */
export const NETWORK_NAMES = ['localnet', 'devnet'] as const;

/** Load the injected deployment envelope. Throws once here when nothing was
 *  injected; the app then reads typed fields off `forNetwork(net)`. */
export const loadDeployment = (): LoadedDeployment => {
	const injected = injectedDeployment();
	if (injected === null || injected === undefined) {
		throw new DevstackConfigMissingError('no deployment was ever injected');
	}
	return loadedFrom(injected);
};

/** Resolve a package id for an MVR placeholder off a loaded deployment.
 *  Throws when the id is missing or unresolved. */
export const requireId = (deployment: NetworkDeployment, mvrPlaceholder: string): string => {
	const id = deployment.mvrOverrides.packages[mvrPlaceholder];
	if (id === undefined || id === UNRESOLVED_ID) {
		throw new DevstackConfigMissingError(`id for "${mvrPlaceholder}" is unresolved`);
	}
	return id;
};

import { loadDeployment, requireId } from './config-runtime.js';
import { NETWORK_NAMES } from './deployment.js';

const __deployment = loadDeployment();
const dep = __deployment.forNetwork(__deployment.defaultNetwork);

export const config = {
	defaultNetwork: __deployment.defaultNetwork as (typeof NETWORK_NAMES)[number],
	forNetwork: __deployment.forNetwork,
	mvrOverrides: {
		packages: {
			'@local/connect-four': requireId(dep, '@local/connect-four'),
		},
		types: {},
	},
	network: dep.network,
	networkNames: NETWORK_NAMES,
	networks: Object.fromEntries(
		__deployment.networkNames.map((n) => [n, __deployment.forNetwork(n)]),
	),
	packages: {
		connect_four: {
			mvr: '@local/connect-four',
			packageId: requireId(dep, '@local/connect-four'),
		},
	},
} as const;

export const dAppKit = createDAppKit({
	// Offer only the networks present in the injected deployment envelope, not
	// the static `networkNames` superset. A prod build drops local networks, so
	// the unfiltered list would let the user select a network absent from
	// `config.networks` — `config.forNetwork` then throws
	// `DevstackConfigMissingError`. Filtering keeps the list and the resolvable
	// set in lockstep while preserving the literal element union.
	networks: [...config.networkNames].filter((n) => config.networks[n] !== undefined),
	defaultNetwork: config.defaultNetwork,
	createClient(network) {
		const net = config.forNetwork(network);
		return new SuiGrpcClient({
			network,
			baseUrl: net.rpc,
			mvr: { overrides: net.mvrOverrides },
		});
	},
});