@algorandfoundation/algokit-utils 10.0.0-alpha.4 → 10.0.0-alpha.41

package/client-manager.js

@@ -0,0 +1,617 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_config = require('./config.js');
+const require_network_client = require('./network-client.js');
+const require_client = require('./packages/algod_client/src/client.js');
+const require_client$1 = require('./packages/indexer_client/src/client.js');
+const require_client$2 = require('./packages/kmd_client/src/client.js');
+const require_app_client = require('./app-client.js');
+const require_app_factory = require('./app-factory.js');
+const require_dispenser_client = require('./dispenser-client.js');
+
+//#region src/client-manager.ts
+/** Exposes access to various API clients. */
+var ClientManager = class ClientManager {
+	_algod;
+	_indexer;
+	_kmd;
+	_algorand;
+	/**
+	* algosdk clients or config for interacting with the official Algorand APIs.
+	* @param clientsOrConfig The clients or config to use
+	* @example Algod client only
+	* ```typescript
+	* const clientManager = new ClientManager({ algod: algodClient })
+	* ```
+	* @example All clients
+	* ```typescript
+	* const clientManager = new ClientManager({ algod: algodClient, indexer: indexerClient, kmd: kmdClient })
+	* ```
+	* @example Algod config only
+	* ```typescript
+	* const clientManager = new ClientManager({ algodConfig })
+	* ```
+	* @example All client configs
+	* ```typescript
+	* const clientManager = new ClientManager({ algodConfig, indexerConfig, kmdConfig })
+	* ```
+	*/
+	constructor(clientsOrConfig, algorandClient) {
+		const _clients = "algod" in clientsOrConfig ? clientsOrConfig : {
+			algod: ClientManager.getAlgodClient(clientsOrConfig.algodConfig),
+			indexer: clientsOrConfig.indexerConfig ? ClientManager.getIndexerClient(clientsOrConfig.indexerConfig) : void 0,
+			kmd: clientsOrConfig.kmdConfig ? ClientManager.getKmdClient(clientsOrConfig.kmdConfig) : void 0
+		};
+		this._algod = _clients.algod;
+		this._indexer = _clients.indexer;
+		this._kmd = _clients.kmd;
+		this._algorand = algorandClient;
+	}
+	/**
+	* Returns an Algod API client.
+	* @returns The Algod client
+	*/
+	get algod() {
+		return this._algod;
+	}
+	/**
+	* Returns an Indexer API client or throws an error if it's not been provided.
+	* @returns The Indexer client
+	* @throws Error if no Indexer client is configured
+	*/
+	get indexer() {
+		if (!this._indexer) throw new Error("Attempt to use Indexer client in AlgoKit instance with no Indexer configured");
+		return this._indexer;
+	}
+	/**
+	* Returns an Indexer API client or `undefined` if it's not been provided.
+	* @returns The Indexer client or `undefined`
+	*/
+	get indexerIfPresent() {
+		return this._indexer;
+	}
+	/**
+	* Returns a KMD API client or throws an error if it's not been provided.
+	* @returns The KMD client
+	* @throws Error if no KMD client is configured
+	*/
+	get kmd() {
+		if (!this._kmd) throw new Error("Attempt to use Kmd client in AlgoKit instance with no Kmd configured");
+		return this._kmd;
+	}
+	_getNetworkPromise;
+	/**
+	* Get details about the current network.
+	* @example Getting genesis ID
+	* ```typescript
+	* const network = await networkClient.network()
+	* const genesisId = network.genesisId
+	* ```
+	* @returns The current network details
+	*/
+	async network() {
+		if (!this._getNetworkPromise) this._getNetworkPromise = this._algod.suggestedParams();
+		const params = await this._getNetworkPromise;
+		return {
+			isTestNet: [
+				"testnet-v1.0",
+				"testnet-v1",
+				"testnet"
+			].includes(params.genesisId ?? "unknown"),
+			isMainNet: [
+				"mainnet-v1.0",
+				"mainnet-v1",
+				"mainnet"
+			].includes(params.genesisId ?? "unknown"),
+			isLocalNet: ClientManager.genesisIdIsLocalNet(params.genesisId ?? "unknown"),
+			genesisId: params.genesisId ?? "unknown",
+			genesisHash: params.genesisHash ? Buffer.from(params.genesisHash).toString("base64") : "unknown"
+		};
+	}
+	/**
+	* Returns true if the given network genesisId is associated with a LocalNet network.
+	* @param genesisId The network genesis ID
+	* @returns Whether the given genesis ID is associated with a LocalNet network
+	* @example
+	* ```typescript
+	* const isLocalNet = ClientManager.genesisIdIsLocalNet('testnet-v1.0')
+	* ```
+	*/
+	static genesisIdIsLocalNet(genesisId) {
+		return require_network_client.genesisIdIsLocalNet(genesisId);
+	}
+	/**
+	* Returns true if the current network is LocalNet.
+	* @returns True if the current network is LocalNet.
+	* @example
+	* ```typescript
+	* const isLocalNet = await clientManager.isLocalNet()
+	* ```
+	*/
+	async isLocalNet() {
+		return (await this.network()).isLocalNet;
+	}
+	/**
+	* Returns true if the current network is TestNet.
+	* @returns True if the current network is TestNet.
+	* @example
+	* ```typescript
+	* const isTestNet = await clientManager.isTestNet()
+	* ```
+	*/
+	async isTestNet() {
+		return (await this.network()).isTestNet;
+	}
+	/**
+	* Returns true if the current network is MainNet.
+	* @returns True if the current network is MainNet.
+	* @example
+	* ```typescript
+	* const isMainNet = await clientManager.isMainNet()
+	* ```
+	*/
+	async isMainNet() {
+		return (await this.network()).isMainNet;
+	}
+	/**
+	* Returns a TestNet Dispenser API client.
+	*
+	* Refer to [docs](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) on guidance to obtain an access token.
+	*
+	* @param params An object containing parameters for the TestNetDispenserApiClient class.
+	* @example
+	* const client = clientManager.getTestNetDispenser(
+	*     {
+	*       authToken: 'your_auth_token',
+	*       requestTimeout: 15,
+	*     }
+	* )
+	*
+	* @returns An instance of the TestNetDispenserApiClient class.
+	*/
+	getTestNetDispenser(params) {
+		return new require_dispenser_client.TestNetDispenserApiClient(params);
+	}
+	/**
+	* Returns a TestNet Dispenser API client, loading the auth token from `process.env.ALGOKIT_DISPENSER_ACCESS_TOKEN`.
+	*
+	* Refer to [docs](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) on guidance to obtain an access token.
+	*
+	* @param params An object containing parameters for the TestNetDispenserApiClient class.
+	* @example
+	* const client = clientManager.getTestNetDispenserFromEnvironment(
+	*     {
+	*       requestTimeout: 15,
+	*     }
+	* )
+	*
+	* @returns An instance of the TestNetDispenserApiClient class.
+	*/
+	getTestNetDispenserFromEnvironment(params) {
+		return new require_dispenser_client.TestNetDispenserApiClient(params ? {
+			...params,
+			authToken: ""
+		} : void 0);
+	}
+	/**
+	* Returns a new `AppFactory` client
+	* @param params The parameters to create the app factory
+	* @example Basic example
+	* ```typescript
+	* const factory = clientManager.getAppFactory({
+	*   appSpec: '{/* ARC-56 or ARC-32 compatible JSON *\/}',
+	* })
+	* ```
+	* @example Advanced example
+	* ```typescript
+	* const factory = clientManager.getAppFactory({
+	*   appSpec: parsedAppSpec_AppSpec_or_Arc56Contract,
+	*   defaultSender: "SENDERADDRESS",
+	*   appName: "OverriddenAppName",
+	*   version: "2.0.0",
+	*   updatable: true,
+	*   deletable: false,
+	*   deployTimeParams: { ONE: 1, TWO: 'value' }
+	* })
+	* ```
+	* @returns The `AppFactory` instance
+	*/
+	getAppFactory(params) {
+		if (!this._algorand) throw new Error("Attempt to get app factory from a ClientManager without an Algorand client");
+		return new require_app_factory.AppFactory({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new `AppClient` client for managing calls and state for an ARC-32/ARC-56 app.
+	* This method resolves the app ID by looking up the creator address and name
+	* using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
+	* @param params The parameters to create the app client
+	* @example Basic
+	* ```typescript
+	* const appClient = clientManager.getAppClientByCreatorAndName({
+	*   appSpec: '{/* ARC-56 or ARC-32 compatible JSON *\}',
+	*   // appId resolved by looking for app ID of named app by this creator
+	*   creatorAddress: 'CREATORADDRESS',
+	* })
+	* ```
+	* @returns The `AppClient` instance
+	*/
+	getAppClientByCreatorAndName(params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return require_app_client.AppClient.fromCreatorAndName({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new `AppClient` client for managing calls and state for an ARC-32/ARC-56 app.
+	* @param params The parameters to create the app client
+	* @example Basic
+	* ```typescript
+	* const appClient = clientManager.getAppClientById({
+	*   appSpec: '{/* ARC-56 or ARC-32 compatible JSON *\}',
+	*   appId: 12345n,
+	* })
+	* ```
+	* @returns The `AppClient` instance
+	*/
+	getAppClientById(params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return new require_app_client.AppClient({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new `AppClient` client for managing calls and state for an ARC-56 app.
+	* This method resolves the app ID for the current network based on
+	* pre-determined network-specific app IDs specified in the ARC-56 app spec.
+	*
+	* If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+	* @param params The parameters to create the app client
+	* @example Basic
+	* ```typescript
+	* const appClient = clientManager.getAppClientByNetwork({
+	*   appSpec: '{/* ARC-56 or ARC-32 compatible JSON *\}',
+	*   // appId resolved by using ARC-56 spec to find app ID for current network
+	* })
+	* ```
+	* @returns The `AppClient` instance
+	*/
+	async getAppClientByNetwork(params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return require_app_client.AppClient.fromNetwork({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new typed client, resolving the app by creator address and name.
+	* @param typedClient The typed client type to use
+	* @param params The params to resolve the app by creator address and name
+	* @example Use name in ARC-32 / ARC-56 app spec
+	* ```typescript
+	* const appClient = clientManager.getTypedAppClientByCreatorAndName(MyContractClient, {
+	*   creatorAddress: "CREATORADDRESS",
+	*   defaultSender: alice,
+	* })
+	* ```
+	* @example Specify name
+	* ```typescript
+	* const appClient = clientManager.getTypedAppClientByCreatorAndName(MyContractClient, {
+	*   creatorAddress: "CREATORADDRESS",
+	*   name: "contract-name",
+	*   defaultSender: alice,
+	* })
+	* ```
+	* @returns The typed client instance
+	*/
+	async getTypedAppClientByCreatorAndName(typedClient, params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return typedClient.fromCreatorAndName({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new typed client, resolving the app by app ID.
+	* @param typedClient The typed client type to use
+	* @param params The params to resolve the app by ID
+	* @example
+	* ```typescript
+	* const appClient = clientManager.getTypedAppClientById(MyContractClient, {
+	*   appId: 12345n,
+	*   defaultSender: alice,
+	* })
+	* ```
+	* @returns The typed client instance
+	*/
+	getTypedAppClientById(typedClient, params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return new typedClient({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new typed client, resolves the app ID for the current network based on
+	* pre-determined network-specific app IDs specified in the ARC-56 app spec.
+	*
+	* If no IDs are in the app spec or the network isn't recognised, an error is thrown.
+	* @param typedClient The typed client type to use
+	* @param params The params to resolve the app by network
+	* @example
+	* ```typescript
+	* const appClient = clientManager.getTypedAppClientByNetwork(MyContractClient, {
+	*   defaultSender: alice,
+	* })
+	* ```
+	* @returns The typed client instance
+	*/
+	getTypedAppClientByNetwork(typedClient, params) {
+		if (!this._algorand) throw new Error("Attempt to get app client from a ClientManager without an Algorand client");
+		return typedClient.fromNetwork({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Returns a new typed app factory.
+	* @param typedFactory The typed factory type to use
+	* @param params The params to resolve the factory by
+	* @example
+	* ```typescript
+	* const appFactory = clientManager.getTypedAppFactory(MyContractClient, {
+	*   sender: alice,
+	* })
+	* ```
+	* @returns The typed client instance
+	*/
+	getTypedAppFactory(typedFactory, params) {
+		if (!this._algorand) throw new Error("Attempt to get app factory from a ClientManager without an Algorand client");
+		return new typedFactory({
+			...params,
+			algorand: this._algorand
+		});
+	}
+	/**
+	* Retrieve client configurations from environment variables when defined or get defaults (expects to be called from a Node.js environment)
+	*
+	* If both `process.env.INDEXER_SERVER` and `process.env.ALGOD_SERVER` is defined it will use both along with optional `process.env.ALGOD_PORT`, `process.env.ALGOD_TOKEN`, `process.env.INDEXER_PORT` and `process.env.INDEXER_TOKEN`.
+	*
+	* If only `process.env.ALGOD_SERVER` is defined it will use this along with optional `process.env.ALGOD_PORT` and `process.env.ALGOD_TOKEN` and leave indexer as `undefined`.
+	*
+	* If only `process.env.INDEXER_SERVER` is defined it will use the default (LocalNet) configuration for both algod and indexer.
+	*
+	* It will return a KMD configuration that uses `process.env.KMD_PORT` (or port 4002) if `process.env.ALGOD_SERVER` is defined,
+	* otherwise it will use the default LocalNet config unless it detects testnet or mainnet.
+	* @example
+	* ```typescript
+	* const config = ClientManager.getConfigFromEnvironmentOrLocalNet()
+	* ```
+	* @returns The config for algod, indexer and kmd
+	*/
+	static getConfigFromEnvironmentOrLocalNet() {
+		if (!process || !process.env) throw new Error("Attempt to get default client configuration from a non Node.js context; supply the config instead");
+		const [algodConfig, indexerConfig, kmdConfig] = process.env.ALGOD_SERVER ? [
+			ClientManager.getAlgodConfigFromEnvironment(),
+			process.env.INDEXER_SERVER ? ClientManager.getIndexerConfigFromEnvironment() : void 0,
+			!process.env.ALGOD_SERVER.includes("mainnet") && !process.env.ALGOD_SERVER.includes("testnet") ? {
+				...ClientManager.getAlgodConfigFromEnvironment(),
+				port: process?.env?.KMD_PORT ?? "4002"
+			} : void 0
+		] : [
+			ClientManager.getDefaultLocalNetConfig("algod"),
+			ClientManager.getDefaultLocalNetConfig("indexer"),
+			ClientManager.getDefaultLocalNetConfig("kmd")
+		];
+		return {
+			algodConfig,
+			indexerConfig,
+			kmdConfig
+		};
+	}
+	/**
+	* Retrieve the algod configuration from environment variables (expects to be called from a Node.js environment)
+	*
+	* Expects `process.env.ALGOD_SERVER` to be defined, and you can also specify `process.env.ALGOD_PORT` and `process.env.ALGOD_TOKEN`.
+	* @returns The Algod client configuration
+	* @throws Error if `process.env.ALGOD_SERVER` is not defined
+	* @example
+	* ```typescript
+	* const config = ClientManager.getAlgodConfigFromEnvironment()
+	* ```
+	*/
+	static getAlgodConfigFromEnvironment() {
+		if (!process || !process.env) throw new Error("Attempt to get default algod configuration from a non Node.js context; supply the config instead");
+		if (!process.env.ALGOD_SERVER) throw new Error("Attempt to get default algod configuration without specifying ALGOD_SERVER in the environment variables");
+		return {
+			server: process.env.ALGOD_SERVER,
+			port: process.env.ALGOD_PORT,
+			token: process.env.ALGOD_TOKEN
+		};
+	}
+	/**
+	* Retrieve the indexer configuration from environment variables (expects to be called from a Node.js environment).
+	*
+	* Expects `process.env.INDEXER_SERVER` to be defined, and you can also specify `process.env.INDEXER_PORT` and `process.env.INDEXER_TOKEN`.
+	* @returns The Indexer client configuration
+	* @throws Error if `process.env.INDEXER_SERVER` is not defined
+	* @example
+	* ```typescript
+	* const config = ClientManager.getIndexerConfigFromEnvironment()
+	* ```
+	*/
+	static getIndexerConfigFromEnvironment() {
+		if (!process || !process.env) throw new Error("Attempt to get default indexer configuration from a non Node.js context; supply the config instead");
+		if (!process.env.INDEXER_SERVER) throw new Error("Attempt to get default indexer configuration without specifying INDEXER_SERVER in the environment variables");
+		return {
+			server: process.env.INDEXER_SERVER,
+			port: process.env.INDEXER_PORT,
+			token: process.env.INDEXER_TOKEN
+		};
+	}
+	/** Returns the Algorand configuration to point to the free tier of the AlgoNode service.
+	*
+	* @param network Which network to connect to - TestNet or MainNet
+	* @param config Which algod config to return - Algod or Indexer
+	* @returns The AlgoNode client configuration
+	* @example
+	* ```typescript
+	* const config = ClientManager.getAlgoNodeConfig('testnet', 'algod')
+	* ```
+	*/
+	static getAlgoNodeConfig(network, config) {
+		return {
+			server: `https://${network}-${config === "algod" ? "api" : "idx"}.algonode.cloud/`,
+			port: 443
+		};
+	}
+	/** Returns the Algorand configuration to point to the default LocalNet.
+	*
+	* @param configOrPort Which algod config to return - algod, kmd, or indexer OR a port number
+	* @returns The LocalNet client configuration
+	* @example
+	* ```typescript
+	* const config = ClientManager.getDefaultLocalNetConfig('algod')
+	* ```
+	*/
+	static getDefaultLocalNetConfig(configOrPort) {
+		return {
+			server: `http://localhost`,
+			port: configOrPort === "algod" ? 4001 : configOrPort === "indexer" ? 8980 : configOrPort === "kmd" ? 4002 : configOrPort,
+			token: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+		};
+	}
+	/**
+	* Returns an algod SDK client that automatically retries on idempotent calls.
+	*
+	* @param config The config of the client
+	* @returns The Algod client
+	* @example AlgoNode (testnet)
+	* ```typescript
+	*  const algod = ClientManager.getAlgodClient(ClientManager.getAlgoNodeConfig('testnet', 'algod'))
+	*  await algod.healthCheck().do()
+	* ```
+	* @example AlgoNode (mainnet)
+	* ```typescript
+	*  const algod = ClientManager.getAlgodClient(ClientManager.getAlgoNodeConfig('mainnet', 'algod'))
+	*  await algod.healthCheck().do()
+	* ```
+	* @example Custom (e.g. default LocalNet)
+	* ```typescript
+	*  const algod = ClientManager.getAlgodClient({server: 'http://localhost', port: '4001', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+	*  await algod.healthCheck().do()
+	* ```
+	*/
+	static getAlgodClient(config) {
+		const { token, server, port } = config;
+		return new require_client.AlgodClient({
+			baseUrl: server,
+			port,
+			token,
+			logger: require_config.Config.logger
+		});
+	}
+	/**
+	* Returns an algod SDK client that automatically retries on idempotent calls loaded from environment variables (expects to be called from a Node.js environment).
+	*
+	* @returns The Algod client
+	* @example
+	*  ```typescript
+	*  // Uses process.env.ALGOD_SERVER, process.env.ALGOD_PORT and process.env.ALGOD_TOKEN
+	*  const algod = ClientManager.getAlgodClientFromEnvironment()
+	*  await algod.healthCheck().do()
+	*  ```
+	*/
+	static getAlgodClientFromEnvironment() {
+		return ClientManager.getAlgodClient(ClientManager.getAlgodConfigFromEnvironment());
+	}
+	/**
+	* Returns an indexer SDK client that automatically retries on idempotent calls
+	*
+	* @param config The config of the client
+	* @returns The Indexer client
+	* @example AlgoNode (testnet)
+	* ```typescript
+	*  const indexer = ClientManager.getIndexerClient(ClientManager.getAlgoNodeConfig('testnet', 'indexer'))
+	*  await indexer.makeHealthCheck().do()
+	* ```
+	* @example AlgoNode (mainnet)
+	* ```typescript
+	*  const indexer = ClientManager.getIndexerClient(ClientManager.getAlgoNodeConfig('mainnet', 'indexer'))
+	*  await indexer.makeHealthCheck().do()
+	* ```
+	* @example Custom (e.g. default LocalNet, although we recommend loading this into a .env and using the Default option instead)
+	* ```typescript
+	*  const indexer = ClientManager.getIndexerClient({server: 'http://localhost', port: '8980', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+	*  await indexer.makeHealthCheck().do()
+	* ```
+	*/
+	static getIndexerClient(config) {
+		const { token, server, port } = config;
+		return new require_client$1.IndexerClient({
+			baseUrl: server,
+			port,
+			token,
+			logger: require_config.Config.logger
+		});
+	}
+	/**
+	* Returns an indexer SDK client that automatically retries on idempotent calls loaded from environment variables (expects to be called from a Node.js environment).
+	*
+	* @returns The Indexer client
+	* @example
+	*
+	*  ```typescript
+	*  // Uses process.env.INDEXER_SERVER, process.env.INDEXER_PORT and process.env.INDEXER_TOKEN
+	*  const indexer = ClientManager.getIndexerClientFromEnvironment()
+	*  await indexer.makeHealthCheck().do()
+	*  ```
+	*/
+	static getIndexerClientFromEnvironment() {
+		return ClientManager.getIndexerClient(ClientManager.getIndexerConfigFromEnvironment());
+	}
+	/**
+	* Returns a KMD SDK client.
+	*
+	* KMD client allows you to export private keys, which is useful to (for instance) get the default account in a LocalNet network.
+	*
+	* @param config The config for the client
+	* @returns The KMD client
+	* @example Custom (e.g. default LocalNet, although we recommend loading this into a .env and using the Default option instead)
+	* ```typescript
+	*  const kmd = ClientManager.getKmdClient({server: 'http://localhost', port: '4002', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+	* ```
+	*/
+	static getKmdClient(config) {
+		const { token, server, port } = config;
+		return new require_client$2.KmdClient({
+			baseUrl: server,
+			port,
+			token,
+			logger: require_config.Config.logger
+		});
+	}
+	/**
+	* Returns a KMD SDK client that automatically retries on idempotent calls loaded from environment variables (expects to be called from a Node.js environment).
+	*
+	* @returns The KMD client
+	* @example
+	*  ```typescript
+	*  // Uses process.env.ALGOD_SERVER, process.env.KMD_PORT (or if not specified: port 4002) and process.env.ALGOD_TOKEN
+	*  const kmd = ClientManager.getKmdClientFromEnvironment()
+	*  ```
+	*/
+	static getKmdClientFromEnvironment() {
+		return ClientManager.getKmdClient({
+			...ClientManager.getAlgodConfigFromEnvironment(),
+			port: process?.env?.KMD_PORT ?? "4002"
+		});
+	}
+};
+
+//#endregion
+exports.ClientManager = ClientManager;
+//# sourceMappingURL=client-manager.js.map