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

package/account/get-account.js

@@ -1,63 +1,60 @@
-'use strict';
-
-var types_accountManager = require('../types/account-manager.js');
-var types_clientManager = require('../types/client-manager.js');
-var getAccountConfigFromEnvironment = require('./get-account-config-from-environment.js');
-
+const require_client_manager = require("../types/client-manager.js");
+const require_account_manager = require("../types/account-manager.js");
+const require_get_account_config_from_environment = require("./get-account-config-from-environment.js");
+//#region src/account/get-account.ts
 /**  @deprecated use `algorand.account.fromEnvironment()` instead
- * Returns an Algorand account with private key loaded by convention based on the given name identifier.
- *
- * Note: This function expects to run in a Node.js environment.
- *
- * ## Convention:
- * * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
- *  never commit it into source control and ideally load it via a secret storage service rather than the file system.
- *   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
- * * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
- *
- * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
- *
- * @example Default
- *
- * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
- * ```typescript
- * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)
- * ```
- *
- * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
- *
- * @param account The details of the account to get, either the name identifier (string) or an object with:
- *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR
- *   * `name`: string: The name identifier of the account (deprecated)
- *   And optionally
- *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
- * @param algod An algod client
- * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables
- * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
- */
+* Returns an Algorand account with private key loaded by convention based on the given name identifier.
+*
+* Note: This function expects to run in a Node.js environment.
+*
+* ## Convention:
+* * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
+*  never commit it into source control and ideally load it via a secret storage service rather than the file system.
+*   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
+* * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
+*
+* This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
+*
+* @example Default
+*
+* If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
+* ```typescript
+* const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)
+* ```
+*
+* If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
+*
+* @param account The details of the account to get, either the name identifier (string) or an object with:
+*   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR
+*   * `name`: string: The name identifier of the account (deprecated)
+*   And optionally
+*   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
+* @param algod An algod client
+* @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables
+* @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
+*/
 async function getAccount(account, algod, kmdClient) {
-    let name;
-    let fundWith = undefined;
-    let config;
-    if (typeof account === 'string') {
-        name = account;
-        config = getAccountConfigFromEnvironment.getAccountConfigFromEnvironment(name);
-    }
-    else if ('name' in account) {
-        name = account.name;
-        config = getAccountConfigFromEnvironment.getAccountConfigFromEnvironment(name);
-        fundWith = account.fundWith;
-    }
-    else if ('config' in account) {
-        config = account.config;
-        name = config.accountName;
-        fundWith = account.fundWith;
-    }
-    else {
-        throw new Error('Missing name or account config');
-    }
-    return (await new types_accountManager.AccountManager(new types_clientManager.ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account;
+	let name;
+	let fundWith = void 0;
+	let config;
+	if (typeof account === "string") {
+		name = account;
+		config = require_get_account_config_from_environment.getAccountConfigFromEnvironment(name);
+	} else if ("name" in account) {
+		name = account.name;
+		config = require_get_account_config_from_environment.getAccountConfigFromEnvironment(name);
+		fundWith = account.fundWith;
+	} else if ("config" in account) {
+		config = account.config;
+		name = config.accountName;
+		fundWith = account.fundWith;
+	} else throw new Error("Missing name or account config");
+	return (await new require_account_manager.AccountManager(new require_client_manager.ClientManager({
+		algod,
+		kmd: kmdClient
+	})).fromEnvironment(name, fundWith)).account;
 }
-
+//#endregion
 exports.getAccount = getAccount;
-//# sourceMappingURL=get-account.js.map
+
+//# sourceMappingURL=get-account.js.map

package/account/get-account.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-account.js","sources":["../../src/account/get-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountConfig, SigningAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { getAccountConfigFromEnvironment } from './get-account-config-from-environment'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n *\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount('ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: The name identifier of the account\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName)\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { config: AccountConfig; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR\n *   * `name`: string: The name identifier of the account (deprecated)\n *   And optionally\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | { config: AccountConfig; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  let name: string\n  let fundWith: AlgoAmount | undefined = undefined\n  let config: AccountConfig\n\n  if (typeof account === 'string') {\n    name = account\n    config = getAccountConfigFromEnvironment(name)\n  } else if ('name' in account) {\n    name = account.name\n    config = getAccountConfigFromEnvironment(name)\n    fundWith = account.fundWith\n  } else if ('config' in account) {\n    config = account.config\n    name = config.accountName\n    fundWith = account.fundWith\n  } else {\n    throw new Error('Missing name or account config')\n  }\n\n  return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account\n}\n"],"names":["getAccountConfigFromEnvironment","AccountManager","ClientManager"],"mappings":";;;;;;AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACI,eAAe,UAAU,CAC9B,OAA4G,EAC5G,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,IAAI,IAAY;IAChB,IAAI,QAAQ,GAA2B,SAAS;AAChD,IAAA,IAAI,MAAqB;AAEzB,IAAA,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;QAC/B,IAAI,GAAG,OAAO;AACd,QAAA,MAAM,GAAGA,+DAA+B,CAAC,IAAI,CAAC;;AACzC,SAAA,IAAI,MAAM,IAAI,OAAO,EAAE;AAC5B,QAAA,IAAI,GAAG,OAAO,CAAC,IAAI;AACnB,QAAA,MAAM,GAAGA,+DAA+B,CAAC,IAAI,CAAC;AAC9C,QAAA,QAAQ,GAAG,OAAO,CAAC,QAAQ;;AACtB,SAAA,IAAI,QAAQ,IAAI,OAAO,EAAE;AAC9B,QAAA,MAAM,GAAG,OAAO,CAAC,MAAM;AACvB,QAAA,IAAI,GAAG,MAAM,CAAC,WAAW;AACzB,QAAA,QAAQ,GAAG,OAAO,CAAC,QAAQ;;SACtB;AACL,QAAA,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC;;IAGnD,OAAO,CAAC,MAAM,IAAIC,mCAAc,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,OAAO;AACzH;;;;"}
+{"version":3,"file":"get-account.js","names":["getAccountConfigFromEnvironment","AccountManager","ClientManager"],"sources":["../../src/account/get-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountConfig, SigningAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { getAccountConfigFromEnvironment } from './get-account-config-from-environment'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n *\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount('ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: The name identifier of the account\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName)\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { config: AccountConfig; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR\n *   * `name`: string: The name identifier of the account (deprecated)\n *   And optionally\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | { config: AccountConfig; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  let name: string\n  let fundWith: AlgoAmount | undefined = undefined\n  let config: AccountConfig\n\n  if (typeof account === 'string') {\n    name = account\n    config = getAccountConfigFromEnvironment(name)\n  } else if ('name' in account) {\n    name = account.name\n    config = getAccountConfigFromEnvironment(name)\n    fundWith = account.fundWith\n  } else if ('config' in account) {\n    config = account.config\n    name = config.accountName\n    fundWith = account.fundWith\n  } else {\n    throw new Error('Missing name or account config')\n  }\n\n  return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,WACpB,SACA,OACA,WACmC;CACnC,IAAI;CACJ,IAAI,WAAmC,KAAA;CACvC,IAAI;CAEJ,IAAI,OAAO,YAAY,UAAU;EAC/B,OAAO;EACP,SAASA,4CAAAA,gCAAgC,IAAI;CAC/C,OAAO,IAAI,UAAU,SAAS;EAC5B,OAAO,QAAQ;EACf,SAASA,4CAAAA,gCAAgC,IAAI;EAC7C,WAAW,QAAQ;CACrB,OAAO,IAAI,YAAY,SAAS;EAC9B,SAAS,QAAQ;EACjB,OAAO,OAAO;EACd,WAAW,QAAQ;CACrB,OACE,MAAM,IAAI,MAAM,gCAAgC;CAGlD,QAAQ,MAAM,IAAIC,wBAAAA,eAAe,IAAIC,uBAAAA,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,gBAAgB,MAAM,QAAQ,EAAA,CAAG;AAClH"}

package/account/get-account.mjs

@@ -1,61 +1,60 @@
-import { AccountManager } from '../types/account-manager.mjs';
-import { ClientManager } from '../types/client-manager.mjs';
-import { getAccountConfigFromEnvironment } from './get-account-config-from-environment.mjs';
-
+import { ClientManager } from "../types/client-manager.mjs";
+import { AccountManager } from "../types/account-manager.mjs";
+import { getAccountConfigFromEnvironment } from "./get-account-config-from-environment.mjs";
+//#region src/account/get-account.ts
 /**  @deprecated use `algorand.account.fromEnvironment()` instead
- * Returns an Algorand account with private key loaded by convention based on the given name identifier.
- *
- * Note: This function expects to run in a Node.js environment.
- *
- * ## Convention:
- * * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
- *  never commit it into source control and ideally load it via a secret storage service rather than the file system.
- *   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
- * * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
- *
- * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
- *
- * @example Default
- *
- * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
- * ```typescript
- * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)
- * ```
- *
- * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
- *
- * @param account The details of the account to get, either the name identifier (string) or an object with:
- *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR
- *   * `name`: string: The name identifier of the account (deprecated)
- *   And optionally
- *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
- * @param algod An algod client
- * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables
- * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
- */
+* Returns an Algorand account with private key loaded by convention based on the given name identifier.
+*
+* Note: This function expects to run in a Node.js environment.
+*
+* ## Convention:
+* * **Non-LocalNet:** will load process.env['\{NAME\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,
+*  never commit it into source control and ideally load it via a secret storage service rather than the file system.
+*   If process.env['\{NAME\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)
+* * **LocalNet:** will load the account from a KMD wallet called \{NAME\} and if that wallet doesn't exist it will create it and fund the account for you
+*
+* This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).
+*
+* @example Default
+*
+* If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
+* ```typescript
+* const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)
+* ```
+*
+* If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
+*
+* @param account The details of the account to get, either the name identifier (string) or an object with:
+*   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR
+*   * `name`: string: The name identifier of the account (deprecated)
+*   And optionally
+*   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account
+* @param algod An algod client
+* @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables
+* @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)
+*/
 async function getAccount(account, algod, kmdClient) {
-    let name;
-    let fundWith = undefined;
-    let config;
-    if (typeof account === 'string') {
-        name = account;
-        config = getAccountConfigFromEnvironment(name);
-    }
-    else if ('name' in account) {
-        name = account.name;
-        config = getAccountConfigFromEnvironment(name);
-        fundWith = account.fundWith;
-    }
-    else if ('config' in account) {
-        config = account.config;
-        name = config.accountName;
-        fundWith = account.fundWith;
-    }
-    else {
-        throw new Error('Missing name or account config');
-    }
-    return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account;
+	let name;
+	let fundWith = void 0;
+	let config;
+	if (typeof account === "string") {
+		name = account;
+		config = getAccountConfigFromEnvironment(name);
+	} else if ("name" in account) {
+		name = account.name;
+		config = getAccountConfigFromEnvironment(name);
+		fundWith = account.fundWith;
+	} else if ("config" in account) {
+		config = account.config;
+		name = config.accountName;
+		fundWith = account.fundWith;
+	} else throw new Error("Missing name or account config");
+	return (await new AccountManager(new ClientManager({
+		algod,
+		kmd: kmdClient
+	})).fromEnvironment(name, fundWith)).account;
 }
-
+//#endregion
 export { getAccount };
-//# sourceMappingURL=get-account.mjs.map
+
+//# sourceMappingURL=get-account.mjs.map

package/account/get-account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-account.mjs","sources":["../../src/account/get-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountConfig, SigningAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { getAccountConfigFromEnvironment } from './get-account-config-from-environment'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n *\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount('ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: The name identifier of the account\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName)\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { config: AccountConfig; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR\n *   * `name`: string: The name identifier of the account (deprecated)\n *   And optionally\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | { config: AccountConfig; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  let name: string\n  let fundWith: AlgoAmount | undefined = undefined\n  let config: AccountConfig\n\n  if (typeof account === 'string') {\n    name = account\n    config = getAccountConfigFromEnvironment(name)\n  } else if ('name' in account) {\n    name = account.name\n    config = getAccountConfigFromEnvironment(name)\n    fundWith = account.fundWith\n  } else if ('config' in account) {\n    config = account.config\n    name = config.accountName\n    fundWith = account.fundWith\n  } else {\n    throw new Error('Missing name or account config')\n  }\n\n  return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account\n}\n"],"names":[],"mappings":";;;;AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACI,eAAe,UAAU,CAC9B,OAA4G,EAC5G,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,IAAI,IAAY;IAChB,IAAI,QAAQ,GAA2B,SAAS;AAChD,IAAA,IAAI,MAAqB;AAEzB,IAAA,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;QAC/B,IAAI,GAAG,OAAO;AACd,QAAA,MAAM,GAAG,+BAA+B,CAAC,IAAI,CAAC;;AACzC,SAAA,IAAI,MAAM,IAAI,OAAO,EAAE;AAC5B,QAAA,IAAI,GAAG,OAAO,CAAC,IAAI;AACnB,QAAA,MAAM,GAAG,+BAA+B,CAAC,IAAI,CAAC;AAC9C,QAAA,QAAQ,GAAG,OAAO,CAAC,QAAQ;;AACtB,SAAA,IAAI,QAAQ,IAAI,OAAO,EAAE;AAC9B,QAAA,MAAM,GAAG,OAAO,CAAC,MAAM;AACvB,QAAA,IAAI,GAAG,MAAM,CAAC,WAAW;AACzB,QAAA,QAAQ,GAAG,OAAO,CAAC,QAAQ;;SACtB;AACL,QAAA,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC;;IAGnD,OAAO,CAAC,MAAM,IAAI,cAAc,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,OAAO;AACzH;;;;"}
+{"version":3,"file":"get-account.mjs","names":[],"sources":["../../src/account/get-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountConfig, SigningAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { getAccountConfigFromEnvironment } from './get-account-config-from-environment'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n *\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount('ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: The name identifier of the account\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName)\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { config: AccountConfig; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount>\n\n/**  @deprecated use `algorand.account.fromEnvironment()` instead\n * Returns an Algorand account with private key loaded by convention based on the given name identifier.\n *\n * Note: This function expects to run in a Node.js environment.\n *\n * ## Convention:\n * * **Non-LocalNet:** will load process.env['\\{NAME\\}_MNEMONIC'] as a mnemonic secret; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it via a secret storage service rather than the file system.\n *   If process.env['\\{NAME\\}_SENDER'] is defined then it will use that for the sender address (i.e. to support rekeyed accounts)\n * * **LocalNet:** will load the account from a KMD wallet called \\{NAME\\} and if that wallet doesn't exist it will create it and fund the account for you\n *\n * This allows you to write code that will work seamlessly in production and local development (LocalNet) without manual config locally (including when you reset the LocalNet).\n *\n * @example Default\n *\n * If you have a mnemonic secret loaded into `process.env.ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await getAccount({config: getAccountConfigFromEnvironment('ACCOUNT')}, algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName) OR\n *   * `name`: string: The name identifier of the account (deprecated)\n *   And optionally\n *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 ALGO will be funded from the dispenser account\n * @param algod An algod client\n * @param kmdClient An optional KMD client to use to create an account (when targeting LocalNet), if not specified then a default KMD client will be loaded from environment variables\n * @returns The requested account with private key loaded from the environment variables or when targeting LocalNet from KMD (idempotently creating and funding the account)\n */\nexport async function getAccount(\n  account: { name: string; fundWith?: AlgoAmount } | { config: AccountConfig; fundWith?: AlgoAmount } | string,\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  let name: string\n  let fundWith: AlgoAmount | undefined = undefined\n  let config: AccountConfig\n\n  if (typeof account === 'string') {\n    name = account\n    config = getAccountConfigFromEnvironment(name)\n  } else if ('name' in account) {\n    name = account.name\n    config = getAccountConfigFromEnvironment(name)\n    fundWith = account.fundWith\n  } else if ('config' in account) {\n    config = account.config\n    name = config.accountName\n    fundWith = account.fundWith\n  } else {\n    throw new Error('Missing name or account config')\n  }\n\n  return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(name, fundWith)).account\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,WACpB,SACA,OACA,WACmC;CACnC,IAAI;CACJ,IAAI,WAAmC,KAAA;CACvC,IAAI;CAEJ,IAAI,OAAO,YAAY,UAAU;EAC/B,OAAO;EACP,SAAS,gCAAgC,IAAI;CAC/C,OAAO,IAAI,UAAU,SAAS;EAC5B,OAAO,QAAQ;EACf,SAAS,gCAAgC,IAAI;EAC7C,WAAW,QAAQ;CACrB,OAAO,IAAI,YAAY,SAAS;EAC9B,SAAS,QAAQ;EACjB,OAAO,OAAO;EACd,WAAW,QAAQ;CACrB,OACE,MAAM,IAAI,MAAM,gCAAgC;CAGlD,QAAQ,MAAM,IAAI,eAAe,IAAI,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,gBAAgB,MAAM,QAAQ,EAAA,CAAG;AAClH"}

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

@@ -1,6 +1,7 @@
-import algosdk from 'algosdk';
-import Algodv2 = algosdk.Algodv2;
-import Kmd = algosdk.Kmd;
+import { SigningAccount, TransactionSignerAccount } from "../types/account.js";
+import algosdk from "algosdk";
+
+//#region src/account/get-dispenser-account.d.ts
 /**
  * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
  *
@@ -12,6 +13,9 @@ 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 getDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<algosdk.Address & import("../types/account").TransactionSignerAccount & {
-    account: import("../types/account").SigningAccount;
+declare function getDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<algosdk.Address & TransactionSignerAccount & {
+  account: SigningAccount;
 }>;
+//#endregion
+export { getDispenserAccount };
+//# sourceMappingURL=get-dispenser-account.d.ts.map

package/account/get-dispenser-account.js

@@ -1,22 +1,24 @@
-'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/account/get-dispenser-account.ts
 /**
- * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
- *
- * Returns an account (with private key loaded) that can act as a dispenser
- *
- * If running on LocalNet then it will return the default dispenser account automatically,
- *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
- *
- * @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.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
+*
+* Returns an account (with private key loaded) that can act as a dispenser
+*
+* If running on LocalNet then it will return the default dispenser account automatically,
+*  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
+*
+* @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 getDispenserAccount(algod, kmd) {
-    return new types_accountManager.AccountManager(new types_clientManager.ClientManager({ algod, kmd })).dispenserFromEnvironment();
+	return new require_account_manager.AccountManager(new require_client_manager.ClientManager({
+		algod,
+		kmd
+	})).dispenserFromEnvironment();
 }
-
+//#endregion
 exports.getDispenserAccount = getDispenserAccount;
-//# sourceMappingURL=get-dispenser-account.js.map
+
+//# sourceMappingURL=get-dispenser-account.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-dispenser-account.js","sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\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 getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"names":["AccountManager","ClientManager"],"mappings":";;;;;AAOA;;;;;;;;;;AAUG;AACI,eAAe,mBAAmB,CAAC,KAAc,EAAE,GAAS,EAAA;AACjE,IAAA,OAAO,IAAIA,mCAAc,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,wBAAwB,EAAE;AACzF;;;;"}
+{"version":3,"file":"get-dispenser-account.js","names":["AccountManager","ClientManager"],"sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\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 getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,eAAsB,oBAAoB,OAAgB,KAAW;CACnE,OAAO,IAAIA,wBAAAA,eAAe,IAAIC,uBAAAA,cAAc;EAAE;EAAO;CAAI,CAAC,CAAC,CAAC,CAAC,yBAAyB;AACxF"}

package/account/get-dispenser-account.mjs

@@ -1,20 +1,24 @@
-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/account/get-dispenser-account.ts
 /**
- * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
- *
- * Returns an account (with private key loaded) that can act as a dispenser
- *
- * If running on LocalNet then it will return the default dispenser account automatically,
- *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
- *
- * @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.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
+*
+* Returns an account (with private key loaded) that can act as a dispenser
+*
+* If running on LocalNet then it will return the default dispenser account automatically,
+*  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
+*
+* @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 getDispenserAccount(algod, kmd) {
-    return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment();
+	return new AccountManager(new ClientManager({
+		algod,
+		kmd
+	})).dispenserFromEnvironment();
 }
-
+//#endregion
 export { getDispenserAccount };
-//# sourceMappingURL=get-dispenser-account.mjs.map
+
+//# sourceMappingURL=get-dispenser-account.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-dispenser-account.mjs","sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\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 getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"names":[],"mappings":";;;AAOA;;;;;;;;;;AAUG;AACI,eAAe,mBAAmB,CAAC,KAAc,EAAE,GAAS,EAAA;AACjE,IAAA,OAAO,IAAI,cAAc,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,wBAAwB,EAAE;AACzF;;;;"}
+{"version":3,"file":"get-dispenser-account.mjs","names":[],"sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\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 getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,eAAsB,oBAAoB,OAAgB,KAAW;CACnE,OAAO,IAAI,eAAe,IAAI,cAAc;EAAE;EAAO;CAAI,CAAC,CAAC,CAAC,CAAC,yBAAyB;AACxF"}

package/account/mnemonic-account.d.ts

@@ -1,5 +1,6 @@
-import algosdk from 'algosdk';
-import Account = algosdk.Account;
+import algosdk from "algosdk";
+
+//#region src/account/mnemonic-account.d.ts
 /**
  * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
  *
@@ -10,4 +11,7 @@ import Account = algosdk.Account;
  * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
  *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
  */
-export declare function mnemonicAccount(mnemonicSecret: string): Account;
+declare function mnemonicAccount(mnemonicSecret: string): Account;
+//#endregion
+export { mnemonicAccount };
+//# sourceMappingURL=mnemonic-account.d.ts.map

package/account/mnemonic-account.js

@@ -1,21 +1,21 @@
-'use strict';
-
-var algosdk = require('algosdk');
-
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+let algosdk = require("algosdk");
+algosdk = require_runtime.__toESM(algosdk);
+//#region src/account/mnemonic-account.ts
 /**
- * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
- *
- * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
- *
- * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
- *
- * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
- *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
- */
+* @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
+*
+* Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
+*
+* This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
+*
+* @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
+*  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
+*/
 function mnemonicAccount(mnemonicSecret) {
-    // This method is confusingly named, so this function provides a more dev friendly "wrapper" name
-    return algosdk.mnemonicToSecretKey(mnemonicSecret);
+	return algosdk.default.mnemonicToSecretKey(mnemonicSecret);
 }
-
+//#endregion
 exports.mnemonicAccount = mnemonicAccount;
-//# sourceMappingURL=mnemonic-account.js.map
+
+//# sourceMappingURL=mnemonic-account.js.map

package/account/mnemonic-account.js.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic-account.js","sources":["../../src/account/mnemonic-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport Account = algosdk.Account\n\n/**\n * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.\n *\n * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.\n *\n * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.\n *\n * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.\n */\nexport function mnemonicAccount(mnemonicSecret: string): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.mnemonicToSecretKey(mnemonicSecret)\n}\n"],"names":[],"mappings":";;;;AAGA;;;;;;;;;AASG;AACG,SAAU,eAAe,CAAC,cAAsB,EAAA;;AAEpD,IAAA,OAAO,OAAO,CAAC,mBAAmB,CAAC,cAAc,CAAC;AACpD;;;;"}
+{"version":3,"file":"mnemonic-account.js","names":[],"sources":["../../src/account/mnemonic-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport Account = algosdk.Account\n\n/**\n * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.\n *\n * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.\n *\n * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.\n *\n * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.\n */\nexport function mnemonicAccount(mnemonicSecret: string): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.mnemonicToSecretKey(mnemonicSecret)\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,gBAAgB,gBAAiC;CAE/D,OAAO,QAAA,QAAQ,oBAAoB,cAAc;AACnD"}

package/account/mnemonic-account.mjs

@@ -1,19 +1,19 @@
-import algosdk from 'algosdk';
-
+import algosdk from "algosdk";
+//#region src/account/mnemonic-account.ts
 /**
- * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
- *
- * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
- *
- * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
- *
- * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
- *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
- */
+* @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
+*
+* Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
+*
+* This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
+*
+* @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
+*  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
+*/
 function mnemonicAccount(mnemonicSecret) {
-    // This method is confusingly named, so this function provides a more dev friendly "wrapper" name
-    return algosdk.mnemonicToSecretKey(mnemonicSecret);
+	return algosdk.mnemonicToSecretKey(mnemonicSecret);
 }
-
+//#endregion
 export { mnemonicAccount };
-//# sourceMappingURL=mnemonic-account.mjs.map
+
+//# sourceMappingURL=mnemonic-account.mjs.map

package/account/mnemonic-account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic-account.mjs","sources":["../../src/account/mnemonic-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport Account = algosdk.Account\n\n/**\n * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.\n *\n * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.\n *\n * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.\n *\n * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.\n */\nexport function mnemonicAccount(mnemonicSecret: string): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.mnemonicToSecretKey(mnemonicSecret)\n}\n"],"names":[],"mappings":";;AAGA;;;;;;;;;AASG;AACG,SAAU,eAAe,CAAC,cAAsB,EAAA;;AAEpD,IAAA,OAAO,OAAO,CAAC,mBAAmB,CAAC,cAAc,CAAC;AACpD;;;;"}
+{"version":3,"file":"mnemonic-account.mjs","names":[],"sources":["../../src/account/mnemonic-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport Account = algosdk.Account\n\n/**\n * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.\n *\n * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.\n *\n * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.\n *\n * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,\n *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.\n */\nexport function mnemonicAccount(mnemonicSecret: string): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.mnemonicToSecretKey(mnemonicSecret)\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,gBAAgB,gBAAiC;CAE/D,OAAO,QAAQ,oBAAoB,cAAc;AACnD"}