configuration.ts

import deepmerge from "deepmerge";
import { readFile, writeFile } from "node:fs/promises";

import debug from "debug";
import {
  HttpProvider,
  Wallet,
  WebsocketProvider,
  type Hex,
  type Provider,
} from "js-moi-sdk";

export type AccountConfig = {
  mnemonic: string;
  path?: string;
};

type ProviderConfiguration = {
  type: "http" | "ws";
  url: string;
};

type AssetConfiguration = {
  asset_id?: Hex;
};

interface ParticipantConfiguration {
  identifier?: Hex;
}

interface LogicConfiguration {
  logic_id?: Hex;
  deployment: {
    manifest: string;
    callsite: string;
    calldata: any[];
  };
}

export interface ConfigurationSetting {
  logs?: boolean;
  account: AccountConfig;
  provider: ProviderConfiguration;
  asset?: AssetConfiguration;
  participant?: ParticipantConfiguration;
  logic: LogicConfiguration;
}

export type ResettableKeys = Exclude<
  keyof ConfigurationSetting,
  "account" | "provider"
>;

const cfgLog = debug("configuration::");
const providerLog = debug("provider::");

class Configuration {
  private configPath: string;

  private configuration: ConfigurationSetting;

  private constructor(path: string, configuration: ConfigurationSetting) {
    this.configPath = path;
    this.configuration = configuration;

    cfgLog("Configuration module loaded");
  }

  public getAccountConfig(): AccountConfig {
    return this.configuration.account;
  }

  public getProviderConfig(): ProviderConfiguration {
    return this.configuration.provider;
  }

  public getConfiguration() {
    return this.configuration;
  }

  public async getWallet() {
    const account = this.getAccountConfig();
    return await Wallet.fromMnemonic(account.mnemonic, account.path, {
      provider: this.getProvider(),
    });
  }

  private async save() {
    await writeFile(
      this.configPath,
      JSON.stringify(this.configuration, null, 2)
    );

    cfgLog("Configuration saved to %s", this.configPath);
  }

  public async setAssetConfig(config: Partial<AssetConfiguration>) {
    this.configuration = deepmerge.all([
      this.configuration,
      { asset: config },
    ]) as ConfigurationSetting;

    await this.save();
  }

  public async setParticipantConfig(config: Partial<ParticipantConfiguration>) {
    this.configuration = deepmerge.all([
      this.configuration,
      { participant: config },
    ]) as ConfigurationSetting;

    await this.save();
  }

  public async setLogicConfig(config: Partial<LogicConfiguration>) {
    this.configuration = deepmerge.all([
      this.configuration,
      { logic: config },
    ]) as ConfigurationSetting;

    await this.save();
  }

  public getProvider(): Provider {
    const config = this.getProviderConfig();
    let provider: Provider;

    switch (config.type) {
      case "http": {
        provider = new HttpProvider(config.url);
        break;
      }

      case "ws": {
        provider = new WebsocketProvider(config.url);
        break;
      }
    }

    if (this.configuration.logs) {
      provider.on("debug", (data) => providerLog(JSON.stringify(data.payload)));
    }

    return provider;
  }

  public async reset(...keys: ResettableKeys[]) {
    for (const key of keys) {
      this.configuration[key] = {} as any;
    }

    await this.save();
  }

  public getConfigurationPath() {
    return this.configPath;
  }

  public static async init(path: string) {
    const content = await readFile(path, "utf8");
    return new Configuration(path, JSON.parse(content));
  }
}

export const config = await Configuration.init("./config/config.json");