@algorandfoundation/algokit-utils 9.2.0 → 9.2.1-beta.1

package/localnet/get-kmd-wallet-account.js

@@ -1,30 +1,32 @@
-'use strict';
-
-var types_clientManager = require('../types/client-manager.js');
-var types_kmdAccountManager = require('../types/kmd-account-manager.js');
-
+const require_client_manager = require("../types/client-manager.js");
+const require_kmd_account_manager = require("../types/kmd-account-manager.js");
+//#region src/localnet/get-kmd-wallet-account.ts
 /**
- * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.
- *
- * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
- *
- * @param walletAccount The details of the wallet, with:
- *   * `name`: The name of the wallet to retrieve an account from
- *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
- * @param algod An algod client
- * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
- * @example Get default funded account in a LocalNet
- *
- * ```typescript
- * const defaultDispenserAccount = await getKmdWalletAccount(algod,
- *   'unencrypted-default-wallet',
- *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
- * )
- * ```
- */
+* @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.
+*
+* Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+*
+* @param walletAccount The details of the wallet, with:
+*   * `name`: The name of the wallet to retrieve an account from
+*   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+* @param algod An algod client
+* @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
+* @example Get default funded account in a LocalNet
+*
+* ```typescript
+* const defaultDispenserAccount = await getKmdWalletAccount(algod,
+*   'unencrypted-default-wallet',
+*   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+* )
+* ```
+*/
 async function getKmdWalletAccount(walletAccount, algod, kmdClient) {
-    return (await new types_kmdAccountManager.KmdAccountManager(new types_clientManager.ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate))?.account;
+	return (await new require_kmd_account_manager.KmdAccountManager(new require_client_manager.ClientManager({
+		algod,
+		kmd: kmdClient
+	})).getWalletAccount(walletAccount.name, walletAccount.predicate))?.account;
 }
-
+//#endregion
 exports.getKmdWalletAccount = getKmdWalletAccount;
-//# sourceMappingURL=get-kmd-wallet-account.js.map
+
+//# sourceMappingURL=get-kmd-wallet-account.js.map

package/localnet/get-kmd-wallet-account.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-kmd-wallet-account.js","sources":["../../src/localnet/get-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.\n *\n * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).\n *\n * @param walletAccount The details of the wallet, with:\n *   * `name`: The name of the wallet to retrieve an account from\n *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n * @example Get default funded account in a LocalNet\n *\n * ```typescript\n * const defaultDispenserAccount = await getKmdWalletAccount(algod,\n *   'unencrypted-default-wallet',\n *   a => a.status !== 'Offline' && a.amount > 1_000_000_000\n * )\n * ```\n */\nexport async function getKmdWalletAccount(\n  walletAccount: {\n    name: string\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    predicate?: (account: Record<string, any>) => boolean\n  },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | undefined> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate)\n  )?.account\n}\n"],"names":["KmdAccountManager","ClientManager"],"mappings":";;;;;AAOA;;;;;;;;;;;;;;;;;;AAkBG;AACI,eAAe,mBAAmB,CACvC,aAIC,EACD,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,OAAO,CACL,MAAM,IAAIA,yCAAiB,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,GACtI,OAAO;AACZ;;;;"}
+{"version":3,"file":"get-kmd-wallet-account.js","names":["KmdAccountManager","ClientManager"],"sources":["../../src/localnet/get-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.\n *\n * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).\n *\n * @param walletAccount The details of the wallet, with:\n *   * `name`: The name of the wallet to retrieve an account from\n *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n * @example Get default funded account in a LocalNet\n *\n * ```typescript\n * const defaultDispenserAccount = await getKmdWalletAccount(algod,\n *   'unencrypted-default-wallet',\n *   a => a.status !== 'Offline' && a.amount > 1_000_000_000\n * )\n * ```\n */\nexport async function getKmdWalletAccount(\n  walletAccount: {\n    name: string\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    predicate?: (account: Record<string, any>) => boolean\n  },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | undefined> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate)\n  )?.account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,oBACpB,eAKA,OACA,WAC8B;CAC9B,QACE,MAAM,IAAIA,4BAAAA,kBAAkB,IAAIC,uBAAAA,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,iBAAiB,cAAc,MAAM,cAAc,SAAS,EAAA,EACrI;AACL"}

package/localnet/get-kmd-wallet-account.mjs

@@ -1,28 +1,32 @@
-import { ClientManager } from '../types/client-manager.mjs';
-import { KmdAccountManager } from '../types/kmd-account-manager.mjs';
-
+import { ClientManager } from "../types/client-manager.mjs";
+import { KmdAccountManager } from "../types/kmd-account-manager.mjs";
+//#region src/localnet/get-kmd-wallet-account.ts
 /**
- * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.
- *
- * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
- *
- * @param walletAccount The details of the wallet, with:
- *   * `name`: The name of the wallet to retrieve an account from
- *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
- * @param algod An algod client
- * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
- * @example Get default funded account in a LocalNet
- *
- * ```typescript
- * const defaultDispenserAccount = await getKmdWalletAccount(algod,
- *   'unencrypted-default-wallet',
- *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
- * )
- * ```
- */
+* @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.
+*
+* Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+*
+* @param walletAccount The details of the wallet, with:
+*   * `name`: The name of the wallet to retrieve an account from
+*   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+* @param algod An algod client
+* @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
+* @example Get default funded account in a LocalNet
+*
+* ```typescript
+* const defaultDispenserAccount = await getKmdWalletAccount(algod,
+*   'unencrypted-default-wallet',
+*   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+* )
+* ```
+*/
 async function getKmdWalletAccount(walletAccount, algod, kmdClient) {
-    return (await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate))?.account;
+	return (await new KmdAccountManager(new ClientManager({
+		algod,
+		kmd: kmdClient
+	})).getWalletAccount(walletAccount.name, walletAccount.predicate))?.account;
 }
-
+//#endregion
 export { getKmdWalletAccount };
-//# sourceMappingURL=get-kmd-wallet-account.mjs.map
+
+//# sourceMappingURL=get-kmd-wallet-account.mjs.map

package/localnet/get-kmd-wallet-account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-kmd-wallet-account.mjs","sources":["../../src/localnet/get-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.\n *\n * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).\n *\n * @param walletAccount The details of the wallet, with:\n *   * `name`: The name of the wallet to retrieve an account from\n *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n * @example Get default funded account in a LocalNet\n *\n * ```typescript\n * const defaultDispenserAccount = await getKmdWalletAccount(algod,\n *   'unencrypted-default-wallet',\n *   a => a.status !== 'Offline' && a.amount > 1_000_000_000\n * )\n * ```\n */\nexport async function getKmdWalletAccount(\n  walletAccount: {\n    name: string\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    predicate?: (account: Record<string, any>) => boolean\n  },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | undefined> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate)\n  )?.account\n}\n"],"names":[],"mappings":";;;AAOA;;;;;;;;;;;;;;;;;;AAkBG;AACI,eAAe,mBAAmB,CACvC,aAIC,EACD,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,OAAO,CACL,MAAM,IAAI,iBAAiB,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,GACtI,OAAO;AACZ;;;;"}
+{"version":3,"file":"get-kmd-wallet-account.mjs","names":[],"sources":["../../src/localnet/get-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getWalletAccount(name, predicate)` or `new KMDAccountManager(clientManager).getWalletAccount(name, predicate)` instead.\n *\n * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).\n *\n * @param walletAccount The details of the wallet, with:\n *   * `name`: The name of the wallet to retrieve an account from\n *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n * @example Get default funded account in a LocalNet\n *\n * ```typescript\n * const defaultDispenserAccount = await getKmdWalletAccount(algod,\n *   'unencrypted-default-wallet',\n *   a => a.status !== 'Offline' && a.amount > 1_000_000_000\n * )\n * ```\n */\nexport async function getKmdWalletAccount(\n  walletAccount: {\n    name: string\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    predicate?: (account: Record<string, any>) => boolean\n  },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | undefined> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getWalletAccount(walletAccount.name, walletAccount.predicate)\n  )?.account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,oBACpB,eAKA,OACA,WAC8B;CAC9B,QACE,MAAM,IAAI,kBAAkB,IAAI,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,iBAAiB,cAAc,MAAM,cAAc,SAAS,EAAA,EACrI;AACL"}

package/localnet/get-localnet-dispenser-account.d.ts

@@ -1,7 +1,6 @@
-import algosdk from 'algosdk';
-import Account = algosdk.Account;
-import Algodv2 = algosdk.Algodv2;
-import Kmd = algosdk.Kmd;
+import algosdk from "algosdk";
+
+//#region src/localnet/get-localnet-dispenser-account.d.ts
 /**
  * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.
  *
@@ -10,4 +9,7 @@ import Kmd = algosdk.Kmd;
  * @param algod An algod client
  * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
  */
-export declare function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account>;
+declare function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account>;
+//#endregion
+export { getLocalNetDispenserAccount };
+//# sourceMappingURL=get-localnet-dispenser-account.d.ts.map

package/localnet/get-localnet-dispenser-account.js

@@ -1,19 +1,21 @@
-'use strict';
-
-var types_accountManager = require('../types/account-manager.js');
-var types_clientManager = require('../types/client-manager.js');
-
+const require_client_manager = require("../types/client-manager.js");
+const require_account_manager = require("../types/account-manager.js");
+//#region src/localnet/get-localnet-dispenser-account.ts
 /**
- * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.
- *
- * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
- *
- * @param algod An algod client
- * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
- */
+* @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.
+*
+* Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
+*
+* @param algod An algod client
+* @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
+*/
 async function getLocalNetDispenserAccount(algod, kmd) {
-    return (await new types_accountManager.AccountManager(new types_clientManager.ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account;
+	return (await new require_account_manager.AccountManager(new require_client_manager.ClientManager({
+		algod,
+		kmd
+	})).kmd.getLocalNetDispenserAccount()).account;
 }
-
+//#endregion
 exports.getLocalNetDispenserAccount = getLocalNetDispenserAccount;
-//# sourceMappingURL=get-localnet-dispenser-account.js.map
+
+//# sourceMappingURL=get-localnet-dispenser-account.js.map

package/localnet/get-localnet-dispenser-account.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-localnet-dispenser-account.js","sources":["../../src/localnet/get-localnet-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n/**\n * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.\n *\n * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account> {\n  return (await new AccountManager(new ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account\n}\n"],"names":["AccountManager","ClientManager"],"mappings":";;;;;AAMA;;;;;;;AAOG;AACI,eAAe,2BAA2B,CAAC,KAAc,EAAE,GAAS,EAAA;IACzE,OAAO,CAAC,MAAM,IAAIA,mCAAc,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,2BAA2B,EAAE,EAAE,OAAO;AAChH;;;;"}
+{"version":3,"file":"get-localnet-dispenser-account.js","names":["AccountManager","ClientManager"],"sources":["../../src/localnet/get-localnet-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n/**\n * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.\n *\n * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account> {\n  return (await new AccountManager(new ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account\n}\n"],"mappings":";;;;;;;;;;;AAcA,eAAsB,4BAA4B,OAAgB,KAA6B;CAC7F,QAAQ,MAAM,IAAIA,wBAAAA,eAAe,IAAIC,uBAAAA,cAAc;EAAE;EAAO;CAAI,CAAC,CAAC,CAAC,CAAC,IAAI,4BAA4B,EAAA,CAAG;AACzG"}

package/localnet/get-localnet-dispenser-account.mjs

@@ -1,17 +1,21 @@
-import { AccountManager } from '../types/account-manager.mjs';
-import { ClientManager } from '../types/client-manager.mjs';
-
+import { ClientManager } from "../types/client-manager.mjs";
+import { AccountManager } from "../types/account-manager.mjs";
+//#region src/localnet/get-localnet-dispenser-account.ts
 /**
- * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.
- *
- * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
- *
- * @param algod An algod client
- * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
- */
+* @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.
+*
+* Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
+*
+* @param algod An algod client
+* @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
+*/
 async function getLocalNetDispenserAccount(algod, kmd) {
-    return (await new AccountManager(new ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account;
+	return (await new AccountManager(new ClientManager({
+		algod,
+		kmd
+	})).kmd.getLocalNetDispenserAccount()).account;
 }
-
+//#endregion
 export { getLocalNetDispenserAccount };
-//# sourceMappingURL=get-localnet-dispenser-account.mjs.map
+
+//# sourceMappingURL=get-localnet-dispenser-account.mjs.map

package/localnet/get-localnet-dispenser-account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-localnet-dispenser-account.mjs","sources":["../../src/localnet/get-localnet-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n/**\n * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.\n *\n * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account> {\n  return (await new AccountManager(new ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account\n}\n"],"names":[],"mappings":";;;AAMA;;;;;;;AAOG;AACI,eAAe,2BAA2B,CAAC,KAAc,EAAE,GAAS,EAAA;IACzE,OAAO,CAAC,MAAM,IAAI,cAAc,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,2BAA2B,EAAE,EAAE,OAAO;AAChH;;;;"}
+{"version":3,"file":"get-localnet-dispenser-account.mjs","names":[],"sources":["../../src/localnet/get-localnet-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n/**\n * @deprecated Use `algorand.account.kmd.getLocalNetDispenserAccount()` instead.\n *\n * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getLocalNetDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<Account> {\n  return (await new AccountManager(new ClientManager({ algod, kmd })).kmd.getLocalNetDispenserAccount()).account\n}\n"],"mappings":";;;;;;;;;;;AAcA,eAAsB,4BAA4B,OAAgB,KAA6B;CAC7F,QAAQ,MAAM,IAAI,eAAe,IAAI,cAAc;EAAE;EAAO;CAAI,CAAC,CAAC,CAAC,CAAC,IAAI,4BAA4B,EAAA,CAAG;AACzG"}

package/localnet/get-or-create-kmd-wallet-account.d.ts

@@ -1,8 +1,7 @@
-import algosdk from 'algosdk';
-import { AlgoAmount } from '../types/amount';
-import Account = algosdk.Account;
-import Algodv2 = algosdk.Algodv2;
-import Kmd = algosdk.Kmd;
+import { AlgoAmount } from "../types/amount.js";
+import algosdk from "algosdk";
+
+//#region src/localnet/get-or-create-kmd-wallet-account.d.ts
 /**
  * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.
  *
@@ -22,7 +21,10 @@ import Kmd = algosdk.Kmd;
  *
  * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
  */
-export declare function getOrCreateKmdWalletAccount(walletAccount: {
-    name: string;
-    fundWith?: AlgoAmount;
+declare function getOrCreateKmdWalletAccount(walletAccount: {
+  name: string;
+  fundWith?: AlgoAmount;
 }, algod: Algodv2, kmdClient?: Kmd): Promise<Account>;
+//#endregion
+export { getOrCreateKmdWalletAccount };
+//# sourceMappingURL=get-or-create-kmd-wallet-account.d.ts.map

package/localnet/get-or-create-kmd-wallet-account.js

@@ -1,30 +1,32 @@
-'use strict';
-
-var types_clientManager = require('../types/client-manager.js');
-var types_kmdAccountManager = require('../types/kmd-account-manager.js');
-
+const require_client_manager = require("../types/client-manager.js");
+const require_kmd_account_manager = require("../types/kmd-account-manager.js");
+//#region src/localnet/get-or-create-kmd-wallet-account.ts
 /**
- * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.
- *
- * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
- *
- * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
- *
- * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
- *
- * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
- *
- * @param walletAccount The wallet details with:
- *   * `name`: The name of the wallet to retrieve / create
- *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
- * @param algod An algod client
- * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
- *
- * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
- */
+* @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.
+*
+* Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+*
+* This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
+*
+* This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
+*
+* If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
+*
+* @param walletAccount The wallet details with:
+*   * `name`: The name of the wallet to retrieve / create
+*   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
+* @param algod An algod client
+* @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
+*
+* @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
+*/
 async function getOrCreateKmdWalletAccount(walletAccount, algod, kmdClient) {
-    return (await new types_kmdAccountManager.KmdAccountManager(new types_clientManager.ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(walletAccount.name, walletAccount.fundWith)).account;
+	return (await new require_kmd_account_manager.KmdAccountManager(new require_client_manager.ClientManager({
+		algod,
+		kmd: kmdClient
+	})).getOrCreateWalletAccount(walletAccount.name, walletAccount.fundWith)).account;
 }
-
+//#endregion
 exports.getOrCreateKmdWalletAccount = getOrCreateKmdWalletAccount;
-//# sourceMappingURL=get-or-create-kmd-wallet-account.js.map
+
+//# sourceMappingURL=get-or-create-kmd-wallet-account.js.map

package/localnet/get-or-create-kmd-wallet-account.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-or-create-kmd-wallet-account.js","sources":["../../src/localnet/get-or-create-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.\n *\n * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.\n *\n * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).\n *\n * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.\n *\n * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!\n *\n * @param walletAccount The wallet details with:\n *   * `name`: The name of the wallet to retrieve / create\n *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n *\n * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you\n */\nexport async function getOrCreateKmdWalletAccount(\n  walletAccount: { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(\n      walletAccount.name,\n      walletAccount.fundWith,\n    )\n  ).account\n}\n"],"names":["KmdAccountManager","ClientManager"],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,eAAe,2BAA2B,CAC/C,aAAsD,EACtD,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,OAAO,CACL,MAAM,IAAIA,yCAAiB,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,wBAAwB,CAChG,aAAa,CAAC,IAAI,EAClB,aAAa,CAAC,QAAQ,CACvB,EACD,OAAO;AACX;;;;"}
+{"version":3,"file":"get-or-create-kmd-wallet-account.js","names":["KmdAccountManager","ClientManager"],"sources":["../../src/localnet/get-or-create-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.\n *\n * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.\n *\n * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).\n *\n * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.\n *\n * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!\n *\n * @param walletAccount The wallet details with:\n *   * `name`: The name of the wallet to retrieve / create\n *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n *\n * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you\n */\nexport async function getOrCreateKmdWalletAccount(\n  walletAccount: { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(\n      walletAccount.name,\n      walletAccount.fundWith,\n    )\n  ).account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,eAAsB,4BACpB,eACA,OACA,WACkB;CAClB,QACE,MAAM,IAAIA,4BAAAA,kBAAkB,IAAIC,uBAAAA,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,yBACxE,cAAc,MACd,cAAc,QAChB,EAAA,CACA;AACJ"}

package/localnet/get-or-create-kmd-wallet-account.mjs

@@ -1,28 +1,32 @@
-import { ClientManager } from '../types/client-manager.mjs';
-import { KmdAccountManager } from '../types/kmd-account-manager.mjs';
-
+import { ClientManager } from "../types/client-manager.mjs";
+import { KmdAccountManager } from "../types/kmd-account-manager.mjs";
+//#region src/localnet/get-or-create-kmd-wallet-account.ts
 /**
- * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.
- *
- * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
- *
- * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
- *
- * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
- *
- * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
- *
- * @param walletAccount The wallet details with:
- *   * `name`: The name of the wallet to retrieve / create
- *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
- * @param algod An algod client
- * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
- *
- * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
- */
+* @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.
+*
+* Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+*
+* This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).
+*
+* This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.
+*
+* If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!
+*
+* @param walletAccount The wallet details with:
+*   * `name`: The name of the wallet to retrieve / create
+*   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account
+* @param algod An algod client
+* @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables
+*
+* @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
+*/
 async function getOrCreateKmdWalletAccount(walletAccount, algod, kmdClient) {
-    return (await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(walletAccount.name, walletAccount.fundWith)).account;
+	return (await new KmdAccountManager(new ClientManager({
+		algod,
+		kmd: kmdClient
+	})).getOrCreateWalletAccount(walletAccount.name, walletAccount.fundWith)).account;
 }
-
+//#endregion
 export { getOrCreateKmdWalletAccount };
-//# sourceMappingURL=get-or-create-kmd-wallet-account.mjs.map
+
+//# sourceMappingURL=get-or-create-kmd-wallet-account.mjs.map

package/localnet/get-or-create-kmd-wallet-account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-or-create-kmd-wallet-account.mjs","sources":["../../src/localnet/get-or-create-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.\n *\n * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.\n *\n * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).\n *\n * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.\n *\n * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!\n *\n * @param walletAccount The wallet details with:\n *   * `name`: The name of the wallet to retrieve / create\n *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n *\n * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you\n */\nexport async function getOrCreateKmdWalletAccount(\n  walletAccount: { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(\n      walletAccount.name,\n      walletAccount.fundWith,\n    )\n  ).account\n}\n"],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,eAAe,2BAA2B,CAC/C,aAAsD,EACtD,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,OAAO,CACL,MAAM,IAAI,iBAAiB,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,wBAAwB,CAChG,aAAa,CAAC,IAAI,EAClB,aAAa,CAAC,QAAQ,CACvB,EACD,OAAO;AACX;;;;"}
+{"version":3,"file":"get-or-create-kmd-wallet-account.mjs","names":[],"sources":["../../src/localnet/get-or-create-kmd-wallet-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { KmdAccountManager } from '../types/kmd-account-manager'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated use `algorand.account.kmd.getOrCreateWalletAccount(name, fundWith)` or `new KMDAccountManager(clientManager).getOrCreateWalletAccount(name, fundWith)` instead.\n *\n * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.\n *\n * This is useful to get idempotent accounts from LocalNet without having to specify the private key (which will change when resetting the LocalNet).\n *\n * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh LocalNet.\n *\n * If this is used via `mnemonicAccountFromEnvironment`, then you can even use the same code that runs on production without changes for local development!\n *\n * @param walletAccount The wallet details with:\n *   * `name`: The name of the wallet to retrieve / create\n *   * `fundWith`: The number of Algo to fund the account with when it gets created, if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables\n *\n * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you\n */\nexport async function getOrCreateKmdWalletAccount(\n  walletAccount: { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account> {\n  return (\n    await new KmdAccountManager(new ClientManager({ algod, kmd: kmdClient })).getOrCreateWalletAccount(\n      walletAccount.name,\n      walletAccount.fundWith,\n    )\n  ).account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,eAAsB,4BACpB,eACA,OACA,WACkB;CAClB,QACE,MAAM,IAAI,kBAAkB,IAAI,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,yBACxE,cAAc,MACd,cAAc,QAChB,EAAA,CACA;AACJ"}

package/localnet/is-localnet.d.ts

@@ -1,7 +1,11 @@
-import algosdk from 'algosdk';
-import Algodv2 = algosdk.Algodv2;
+import algosdk from "algosdk";
+
+//#region src/localnet/is-localnet.d.ts
 /** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.
  *
  * Returns true if the algod client is pointing to a LocalNet Algorand network
  */
-export declare function isLocalNet(algod: Algodv2): Promise<boolean>;
+declare function isLocalNet(algod: Algodv2): Promise<boolean>;
+//#endregion
+export { isLocalNet };
+//# sourceMappingURL=is-localnet.d.ts.map

package/localnet/is-localnet.js

@@ -1,14 +1,13 @@
-'use strict';
-
-var types_clientManager = require('../types/client-manager.js');
-
+const require_client_manager = require("../types/client-manager.js");
+//#region src/localnet/is-localnet.ts
 /** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.
- *
- * Returns true if the algod client is pointing to a LocalNet Algorand network
- */
+*
+* Returns true if the algod client is pointing to a LocalNet Algorand network
+*/
 async function isLocalNet(algod) {
-    return await new types_clientManager.ClientManager({ algod }).isLocalNet();
+	return await new require_client_manager.ClientManager({ algod }).isLocalNet();
 }
-
+//#endregion
 exports.isLocalNet = isLocalNet;
-//# sourceMappingURL=is-localnet.js.map
+
+//# sourceMappingURL=is-localnet.js.map

package/localnet/is-localnet.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-localnet.js","sources":["../../src/localnet/is-localnet.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport Algodv2 = algosdk.Algodv2\n\n/** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.\n *\n * Returns true if the algod client is pointing to a LocalNet Algorand network\n */\nexport async function isLocalNet(algod: Algodv2): Promise<boolean> {\n  return await new ClientManager({ algod }).isLocalNet()\n}\n"],"names":["ClientManager"],"mappings":";;;;AAIA;;;AAGG;AACI,eAAe,UAAU,CAAC,KAAc,EAAA;IAC7C,OAAO,MAAM,IAAIA,iCAAa,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,UAAU,EAAE;AACxD;;;;"}
+{"version":3,"file":"is-localnet.js","names":["ClientManager"],"sources":["../../src/localnet/is-localnet.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport Algodv2 = algosdk.Algodv2\n\n/** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.\n *\n * Returns true if the algod client is pointing to a LocalNet Algorand network\n */\nexport async function isLocalNet(algod: Algodv2): Promise<boolean> {\n  return await new ClientManager({ algod }).isLocalNet()\n}\n"],"mappings":";;;;;;AAQA,eAAsB,WAAW,OAAkC;CACjE,OAAO,MAAM,IAAIA,uBAAAA,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW;AACvD"}

package/localnet/is-localnet.mjs

@@ -1,12 +1,13 @@
-import { ClientManager } from '../types/client-manager.mjs';
-
+import { ClientManager } from "../types/client-manager.mjs";
+//#region src/localnet/is-localnet.ts
 /** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.
- *
- * Returns true if the algod client is pointing to a LocalNet Algorand network
- */
+*
+* Returns true if the algod client is pointing to a LocalNet Algorand network
+*/
 async function isLocalNet(algod) {
-    return await new ClientManager({ algod }).isLocalNet();
+	return await new ClientManager({ algod }).isLocalNet();
 }
-
+//#endregion
 export { isLocalNet };
-//# sourceMappingURL=is-localnet.mjs.map
+
+//# sourceMappingURL=is-localnet.mjs.map

package/localnet/is-localnet.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-localnet.mjs","sources":["../../src/localnet/is-localnet.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport Algodv2 = algosdk.Algodv2\n\n/** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.\n *\n * Returns true if the algod client is pointing to a LocalNet Algorand network\n */\nexport async function isLocalNet(algod: Algodv2): Promise<boolean> {\n  return await new ClientManager({ algod }).isLocalNet()\n}\n"],"names":[],"mappings":";;AAIA;;;AAGG;AACI,eAAe,UAAU,CAAC,KAAc,EAAA;IAC7C,OAAO,MAAM,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,UAAU,EAAE;AACxD;;;;"}
+{"version":3,"file":"is-localnet.mjs","names":[],"sources":["../../src/localnet/is-localnet.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { ClientManager } from '../types/client-manager'\nimport Algodv2 = algosdk.Algodv2\n\n/** @deprecated Use `await algorand.client.isLocalNet()` or `await new ClientManager({ algod }).isLocalNet()` instead.\n *\n * Returns true if the algod client is pointing to a LocalNet Algorand network\n */\nexport async function isLocalNet(algod: Algodv2): Promise<boolean> {\n  return await new ClientManager({ algod }).isLocalNet()\n}\n"],"mappings":";;;;;;AAQA,eAAsB,WAAW,OAAkC;CACjE,OAAO,MAAM,IAAI,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW;AACvD"}

package/network-client.d.ts

@@ -1,26 +1,25 @@
-import algosdk from 'algosdk';
-import { AlgoClientConfig, AlgoConfig } from './types/network-client';
-import Algodv2 = algosdk.Algodv2;
-import Indexer = algosdk.Indexer;
-import Kmd = algosdk.Kmd;
+import { AlgoClientConfig, AlgoConfig } from "./types/network-client.js";
+import algosdk from "algosdk";
+
+//#region src/network-client.d.ts
 /**
  * @deprecated Use `ClientManager.getConfigFromEnvironmentOrLocalNet()` instead.
  *
  * Retrieve configurations from environment variables when defined or get defaults (expects to be called from a Node.js environment not algod-side)
  */
-export declare function getConfigFromEnvOrDefaults(): AlgoConfig;
+declare function getConfigFromEnvOrDefaults(): AlgoConfig;
 /**
  * @deprecated Use `ClientManager.getAlgodConfigFromEnvironment()` instead.
  *
  * Retrieve the algod configuration from environment variables (expects to be called from a Node.js environment not algod-side)
  */
-export declare function getAlgodConfigFromEnvironment(): AlgoClientConfig;
+declare function getAlgodConfigFromEnvironment(): AlgoClientConfig;
 /**
  * @deprecated Use `ClientManager.getIndexerConfigFromEnvironment()` instead.
  *
  * Retrieve the indexer configuration from environment variables (expects to be called from a Node.js environment not algod-side)
  */
-export declare function getIndexerConfigFromEnvironment(): AlgoClientConfig;
+declare function getIndexerConfigFromEnvironment(): AlgoClientConfig;
 /**
  * @deprecated Use `ClientManager.getAlgoNodeConfig(network, config)` instead.
  *
@@ -29,7 +28,7 @@ export declare function getIndexerConfigFromEnvironment(): AlgoClientConfig;
  * @param network Which network to connect to - TestNet or MainNet
  * @param config Which algod config to return - Algod or Indexer
  */
-export declare function getAlgoNodeConfig(network: 'testnet' | 'mainnet', config: 'algod' | 'indexer'): AlgoClientConfig;
+declare function getAlgoNodeConfig(network: 'testnet' | 'mainnet', config: 'algod' | 'indexer'): AlgoClientConfig;
 /**
  * @deprecated Use `ClientManager.getDefaultLocalNetConfig(configOrPort)` instead.
  *
@@ -37,7 +36,7 @@ export declare function getAlgoNodeConfig(network: 'testnet' | 'mainnet', config
  *
  * @param configOrPort Which algod config to return - algod, kmd, or indexer OR a port number
  */
-export declare function getDefaultLocalNetConfig(configOrPort: 'algod' | 'indexer' | 'kmd' | number): AlgoClientConfig;
+declare function getDefaultLocalNetConfig(configOrPort: 'algod' | 'indexer' | 'kmd' | number): AlgoClientConfig;
 /**
  * @deprecated Use `ClientManager.getAlgodClient(config)` or `ClientManager.getAlgodClientFromEnvironment()` instead.
  *
@@ -68,7 +67,7 @@ export declare function getDefaultLocalNetConfig(configOrPort: 'algod' | 'indexe
  *  await algod.healthCheck().do()
  * ```
  */
-export declare function getAlgoClient(config?: AlgoClientConfig): Algodv2;
+declare function getAlgoClient(config?: AlgoClientConfig): Algodv2;
 /**
  * @deprecated Use `ClientManager.getIndexerClient(config, overrideIntDecoding)` or `ClientManager.getIndexerClientFromEnvironment(overrideIntDecoding)` instead.
  *
@@ -98,7 +97,7 @@ export declare function getAlgoClient(config?: AlgoClientConfig): Algodv2;
  *  await indexer.makeHealthCheck().do()
  * ```
  */
-export declare function getAlgoIndexerClient(config?: AlgoClientConfig): Indexer;
+declare function getAlgoIndexerClient(config?: AlgoClientConfig): Indexer;
 /**
  * @deprecated Use `ClientManager.getKmdClient(config)` or `ClientManager.getKmdClientFromEnvironment()` instead.
  *
@@ -118,8 +117,11 @@ export declare function getAlgoIndexerClient(config?: AlgoClientConfig): Indexer
  *  const kmd = getAlgoKmdClient({server: 'http://localhost', port: '4002', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
  * ```
  */
-export declare function getAlgoKmdClient(config?: AlgoClientConfig): Kmd;
+declare function getAlgoKmdClient(config?: AlgoClientConfig): Kmd;
 /** @deprecated Use `await algorand.client.isTestNet()` or `await new ClientManager({ algod }).isTestNet()` instead. */
-export declare function isTestNet(algod: Algodv2): Promise<boolean>;
+declare function isTestNet(algod: Algodv2): Promise<boolean>;
 /** @deprecated Use `await algorand.client.isMainNet()` or `await new ClientManager({ algod }).isMainNet()` instead. */
-export declare function isMainNet(algod: Algodv2): Promise<boolean>;
+declare function isMainNet(algod: Algodv2): Promise<boolean>;
+//#endregion
+export { getAlgoClient, getAlgoIndexerClient, getAlgoKmdClient, getAlgoNodeConfig, getAlgodConfigFromEnvironment, getConfigFromEnvOrDefaults, getDefaultLocalNetConfig, getIndexerConfigFromEnvironment, isMainNet, isTestNet };
+//# sourceMappingURL=network-client.d.ts.map