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

package/account/account.mjs

@@ -1,172 +1,177 @@
-import algosdk, { Address } from 'algosdk';
-import { getSenderAddress } from '../transaction/transaction.mjs';
-import { MultisigAccount, SigningAccount } from '../types/account.mjs';
-import { AccountManager } from '../types/account-manager.mjs';
-import { AlgorandClient } from '../types/algorand-client.mjs';
-import { ClientManager } from '../types/client-manager.mjs';
-
+import { getSenderAddress } from "../transaction/transaction.mjs";
+import { MultisigAccount, SigningAccount } from "../types/account.mjs";
+import { ClientManager } from "../types/client-manager.mjs";
+import { AccountManager } from "../types/account-manager.mjs";
+import { AlgorandClient } from "../types/algorand-client.mjs";
+import algosdk, { Address } from "algosdk";
+//#region src/account/account.ts
 /**
- * @deprecated Use `algorand.account.multisig(multisigParams, signingAccounts)` or `new MultisigAccount(multisigParams, signingAccounts)` instead.
- *
- * Returns an account wrapper that supports partial or full multisig signing.
- * @param multisigParams The parameters that define the multisig account
- * @param signingAccounts The signers that are currently present
- * @returns A multisig account wrapper
- */
+* @deprecated Use `algorand.account.multisig(multisigParams, signingAccounts)` or `new MultisigAccount(multisigParams, signingAccounts)` instead.
+*
+* Returns an account wrapper that supports partial or full multisig signing.
+* @param multisigParams The parameters that define the multisig account
+* @param signingAccounts The signers that are currently present
+* @returns A multisig account wrapper
+*/
 function multisigAccount(multisigParams, signingAccounts) {
-    return new MultisigAccount(multisigParams, signingAccounts);
+	return new MultisigAccount(multisigParams, signingAccounts);
 }
 /**
- * @deprecated Use `algorand.account.rekeyed(sender, account)` or `new SigningAccount(account, sender)` instead.
- *
- * Returns an account wrapper that supports a rekeyed account.
- * @param signer The account, with private key loaded, that is signing
- * @param sender The address of the rekeyed account that will act as a sender
- * @returns The SigningAccount wrapper
- */
+* @deprecated Use `algorand.account.rekeyed(sender, account)` or `new SigningAccount(account, sender)` instead.
+*
+* Returns an account wrapper that supports a rekeyed account.
+* @param signer The account, with private key loaded, that is signing
+* @param sender The address of the rekeyed account that will act as a sender
+* @returns The SigningAccount wrapper
+*/
 function rekeyedAccount(signer, sender) {
-    return new SigningAccount(signer, sender);
+	return new SigningAccount(signer, sender);
 }
 /**
- * @deprecated Use `algorand.account.getSigner(sender)` (after previously registering the signer with `setSigner`) or `{ addr: sender, signer }` instead.
- *
- * Returns an account wrapper that supports a transaction signer with associated sender address.
- * @param signer The transaction signer
- * @param sender The address of sender account
- * @returns The SigningAccount wrapper
- */
+* @deprecated Use `algorand.account.getSigner(sender)` (after previously registering the signer with `setSigner`) or `{ addr: sender, signer }` instead.
+*
+* Returns an account wrapper that supports a transaction signer with associated sender address.
+* @param signer The transaction signer
+* @param sender The address of sender account
+* @returns The SigningAccount wrapper
+*/
 function transactionSignerAccount(signer, sender) {
-    return { addr: Address.fromString(sender), signer };
+	return {
+		addr: Address.fromString(sender),
+		signer
+	};
 }
 /**
- * @deprecated Use `algorand.account.random()` or `algosdk.generateAccount()` instead.
- *
- * Returns a new, random Algorand account with secret key loaded.
- *
- * This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.
- *
- */
+* @deprecated Use `algorand.account.random()` or `algosdk.generateAccount()` instead.
+*
+* Returns a new, random Algorand account with secret key loaded.
+*
+* This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.
+*
+*/
 function randomAccount() {
-    // This method is confusingly named, so this function provides a more dev friendly "wrapper" name
-    return algosdk.generateAccount();
+	return algosdk.generateAccount();
 }
 /**
- * @deprecated Use `algorand.account.fromEnvironment(name, fundWith)` or `new AccountManager(clientManager).fromEnvironment()` instead.
- *
- * Returns an Algorand account with private key loaded by convention from environment variables 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.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
- * ```typescript
- * const account = await mnemonicAccountFromEnvironment('MY_ACCOUNT', algod)
- * ```
- *
- * If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
- * If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.
- *
- * @param account The details of the account to get, either the name identifier (string) or an object with:
- *   * `name`: string: The name identifier of the account
- *   * `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)
- */
+* @deprecated Use `algorand.account.fromEnvironment(name, fundWith)` or `new AccountManager(clientManager).fromEnvironment()` instead.
+*
+* Returns an Algorand account with private key loaded by convention from environment variables 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.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:
+* ```typescript
+* const account = await mnemonicAccountFromEnvironment('MY_ACCOUNT', algod)
+* ```
+*
+* If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.
+* If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.
+*
+* @param account The details of the account to get, either the name identifier (string) or an object with:
+*   * `name`: string: The name identifier of the account
+*   * `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 mnemonicAccountFromEnvironment(account, algod, kmdClient) {
-    return (await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(typeof account === 'string' ? account : account.name, typeof account === 'string' ? undefined : account.fundWith)).account;
+	return (await new AccountManager(new ClientManager({
+		algod,
+		kmd: kmdClient
+	})).fromEnvironment(typeof account === "string" ? account : account.name, typeof account === "string" ? void 0 : account.fundWith)).account;
 }
 /**
- * @deprecated Use `algosdk.decodeAddress` instead.
- *
- * Returns an account's address as a byte array
- *
- * @param account Either an account (with private key loaded) or the string address of an account
- */
+* @deprecated Use `algosdk.decodeAddress` instead.
+*
+* Returns an account's address as a byte array
+*
+* @param account Either an account (with private key loaded) or the string address of an account
+*/
 function getAccountAddressAsUint8Array(account) {
-    return algosdk.decodeAddress(typeof account === 'string' ? account : getSenderAddress(account)).publicKey;
+	return algosdk.decodeAddress(typeof account === "string" ? account : getSenderAddress(account)).publicKey;
 }
 /**
- * @deprecated Use `algosdk.encodeAddress` instead.
- *
- * Returns the string address of an Algorand account from a base64 encoded version of the underlying byte array of the address public key
- *
- * @param addressEncodedInB64 The base64 encoded version of the underlying byte array of the address public key
- */
+* @deprecated Use `algosdk.encodeAddress` instead.
+*
+* Returns the string address of an Algorand account from a base64 encoded version of the underlying byte array of the address public key
+*
+* @param addressEncodedInB64 The base64 encoded version of the underlying byte array of the address public key
+*/
 function getAccountAddressAsString(addressEncodedInB64) {
-    return algosdk.encodeAddress(Buffer.from(addressEncodedInB64, 'base64'));
+	return algosdk.encodeAddress(Buffer.from(addressEncodedInB64, "base64"));
 }
 /**
- * @deprecated Use `algorand.account.getInformation(sender)` or `new AccountManager(clientManager).getInformation(sender)` instead.
- *
- * Returns the given sender account's current status, balance and spendable amounts.
- *
- * @example
- * ```typescript
- * const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
- * const accountInfo = await account.getInformation(address, algod);
- * ```
- *
- * [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountinformation)
- * @param sender The address of the sender/account to look up
- * @param algod The algod instance
- * @returns The account information
- */
+* @deprecated Use `algorand.account.getInformation(sender)` or `new AccountManager(clientManager).getInformation(sender)` instead.
+*
+* Returns the given sender account's current status, balance and spendable amounts.
+*
+* @example
+* ```typescript
+* const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
+* const accountInfo = await account.getInformation(address, algod);
+* ```
+*
+* [Response data schema details](https://dev.algorand.co/reference/rest-api/algod/operations/accountinformation/)
+* @param sender The address of the sender/account to look up
+* @param algod The algod instance
+* @returns The account information
+*/
 async function getAccountInformation(sender, algod) {
-    const account = await algod.accountInformation(getSenderAddress(sender)).do();
-    return {
-        ...account,
-        address: account.address.toString(),
-        authAddr: account.authAddr ? account.authAddr.toString() : undefined,
-        // None of these can practically overflow 2^53
-        amount: Number(account.amount),
-        amountWithoutPendingRewards: Number(account.amountWithoutPendingRewards),
-        minBalance: Number(account.minBalance),
-        pendingRewards: Number(account.pendingRewards),
-        rewards: Number(account.rewards),
-        round: Number(account.round),
-        totalAppsOptedIn: Number(account.totalAppsOptedIn),
-        totalAssetsOptedIn: Number(account.totalAssetsOptedIn),
-        totalCreatedApps: Number(account.totalCreatedApps),
-        totalCreatedAssets: Number(account.totalCreatedAssets),
-        appsTotalExtraPages: account.appsTotalExtraPages !== undefined ? Number(account.appsTotalExtraPages) : undefined,
-        rewardBase: account.rewardBase !== undefined ? Number(account.rewardBase) : undefined,
-        totalBoxBytes: account.totalBoxBytes !== undefined ? Number(account.totalBoxBytes) : undefined,
-        totalBoxes: account.totalBoxes !== undefined ? Number(account.totalBoxes) : undefined,
-        lastHeartbeat: account.lastHeartbeat !== undefined ? Number(account.lastHeartbeat) : undefined,
-        lastProposed: account.lastProposed !== undefined ? Number(account.lastProposed) : undefined,
-    };
+	const account = await algod.accountInformation(getSenderAddress(sender)).do();
+	return {
+		...account,
+		address: account.address.toString(),
+		authAddr: account.authAddr ? account.authAddr.toString() : void 0,
+		amount: Number(account.amount),
+		amountWithoutPendingRewards: Number(account.amountWithoutPendingRewards),
+		minBalance: Number(account.minBalance),
+		pendingRewards: Number(account.pendingRewards),
+		rewards: Number(account.rewards),
+		round: Number(account.round),
+		totalAppsOptedIn: Number(account.totalAppsOptedIn),
+		totalAssetsOptedIn: Number(account.totalAssetsOptedIn),
+		totalCreatedApps: Number(account.totalCreatedApps),
+		totalCreatedAssets: Number(account.totalCreatedAssets),
+		appsTotalExtraPages: account.appsTotalExtraPages !== void 0 ? Number(account.appsTotalExtraPages) : void 0,
+		rewardBase: account.rewardBase !== void 0 ? Number(account.rewardBase) : void 0,
+		totalBoxBytes: account.totalBoxBytes !== void 0 ? Number(account.totalBoxBytes) : void 0,
+		totalBoxes: account.totalBoxes !== void 0 ? Number(account.totalBoxes) : void 0,
+		lastHeartbeat: account.lastHeartbeat !== void 0 ? Number(account.lastHeartbeat) : void 0,
+		lastProposed: account.lastProposed !== void 0 ? Number(account.lastProposed) : void 0
+	};
 }
 /**
- * @deprecated Use `algorand.asset.getAccountInformation(sender, assetId)` or `new AssetManager(...).getAccountInformation(sender, assetId)` instead.
- *
- * Returns the given sender account's asset holding for a given asset.
- *
- * @example
- * ```typescript
- * const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
- * const assetId = 123345;
- * const accountInfo = await account.getAccountAssetInformation(address, assetId, algod);
- * ```
- *
- * [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountassetinformation)
- * @param sender The address of the sender/account to look up
- * @param assetId The ID of the asset to return a holding for
- * @param algod The algod instance
- * @returns The account asset holding information
- */
+* @deprecated Use `algorand.asset.getAccountInformation(sender, assetId)` or `new AssetManager(...).getAccountInformation(sender, assetId)` instead.
+*
+* Returns the given sender account's asset holding for a given asset.
+*
+* @example
+* ```typescript
+* const address = "XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA";
+* const assetId = 123345;
+* const accountInfo = await account.getAccountAssetInformation(address, assetId, algod);
+* ```
+*
+* [Response data schema details](https://dev.algorand.co/reference/rest-api/algod/operations/accountassetinformation/)
+* @param sender The address of the sender/account to look up
+* @param assetId The ID of the asset to return a holding for
+* @param algod The algod instance
+* @returns The account asset holding information
+*/
 async function getAccountAssetInformation(sender, assetId, algod) {
-    return AlgorandClient.fromClients({ algod }).asset.getAccountInformation(getSenderAddress(sender), BigInt(assetId));
+	return AlgorandClient.fromClients({ algod }).asset.getAccountInformation(getSenderAddress(sender), BigInt(assetId));
 }
-
+//#endregion
 export { getAccountAddressAsString, getAccountAddressAsUint8Array, getAccountAssetInformation, getAccountInformation, mnemonicAccountFromEnvironment, multisigAccount, randomAccount, rekeyedAccount, transactionSignerAccount };
-//# sourceMappingURL=account.mjs.map
+
+//# sourceMappingURL=account.mjs.map

package/account/account.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"account.mjs","sources":["../../src/account/account.ts"],"sourcesContent":["import algosdk, { Address } from 'algosdk'\nimport { getSenderAddress } from '../transaction/transaction'\nimport { AccountAssetInformation, MultisigAccount, SigningAccount, TransactionSignerAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgorandClient } from '../types/algorand-client'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { SendTransactionFrom } from '../types/transaction'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\nimport MultisigMetadata = algosdk.MultisigMetadata\nimport TransactionSigner = algosdk.TransactionSigner\nimport AccountInformationModel = algosdk.modelsv2.Account\n\n/**\n * @deprecated Use `algorand.account.multisig(multisigParams, signingAccounts)` or `new MultisigAccount(multisigParams, signingAccounts)` instead.\n *\n * Returns an account wrapper that supports partial or full multisig signing.\n * @param multisigParams The parameters that define the multisig account\n * @param signingAccounts The signers that are currently present\n * @returns A multisig account wrapper\n */\nexport function multisigAccount(multisigParams: MultisigMetadata, signingAccounts: (Account | SigningAccount)[]) {\n  return new MultisigAccount(multisigParams, signingAccounts)\n}\n\n/**\n * @deprecated Use `algorand.account.rekeyed(sender, account)` or `new SigningAccount(account, sender)` instead.\n *\n * Returns an account wrapper that supports a rekeyed account.\n * @param signer The account, with private key loaded, that is signing\n * @param sender The address of the rekeyed account that will act as a sender\n * @returns The SigningAccount wrapper\n */\nexport function rekeyedAccount(signer: Account, sender: string) {\n  return new SigningAccount(signer, sender)\n}\n\n/**\n * @deprecated Use `algorand.account.getSigner(sender)` (after previously registering the signer with `setSigner`) or `{ addr: sender, signer }` instead.\n *\n * Returns an account wrapper that supports a transaction signer with associated sender address.\n * @param signer The transaction signer\n * @param sender The address of sender account\n * @returns The SigningAccount wrapper\n */\nexport function transactionSignerAccount(signer: TransactionSigner, sender: string): TransactionSignerAccount {\n  return { addr: Address.fromString(sender), signer }\n}\n\n/**\n * @deprecated Use `algorand.account.random()` or `algosdk.generateAccount()` instead.\n *\n * Returns a new, random Algorand account with secret key loaded.\n *\n * This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.\n *\n */\nexport function randomAccount(): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.generateAccount()\n}\n\n/**\n * @deprecated Use `algorand.account.fromEnvironment(name, fundWith)` or `new AccountManager(clientManager).fromEnvironment()` instead.\n *\n * Returns an Algorand account with private key loaded by convention from environment variables 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.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await mnemonicAccountFromEnvironment('MY_ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n * If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: string: 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 mnemonicAccountFromEnvironment(\n  account: string | { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  return (\n    await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(\n      typeof account === 'string' ? account : account.name,\n      typeof account === 'string' ? undefined : account.fundWith,\n    )\n  ).account\n}\n\n/**\n * @deprecated Use `algosdk.decodeAddress` instead.\n *\n * Returns an account's address as a byte array\n *\n * @param account Either an account (with private key loaded) or the string address of an account\n */\nexport function getAccountAddressAsUint8Array(account: SendTransactionFrom | string) {\n  return algosdk.decodeAddress(typeof account === 'string' ? account : getSenderAddress(account)).publicKey\n}\n\n/**\n * @deprecated Use `algosdk.encodeAddress` instead.\n *\n * Returns the string address of an Algorand account from a base64 encoded version of the underlying byte array of the address public key\n *\n * @param addressEncodedInB64 The base64 encoded version of the underlying byte array of the address public key\n */\nexport function getAccountAddressAsString(addressEncodedInB64: string): string {\n  return algosdk.encodeAddress(Buffer.from(addressEncodedInB64, 'base64'))\n}\n\nexport type NumberConverter<T extends AccountInformationModel> = { [key in keyof T]: ToNumberIfExtends<T[key], number | bigint> }\ntype ToNumberIfExtends<K, E> = K extends E ? number : K\n/** @deprecated Account information at a given round. */\nexport type AccountInformation = Omit<NumberConverter<AccountInformationModel>, 'getEncodingSchema' | 'toEncodingData' | 'authAddr'> & {\n  /** (spend) the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field. */\n  authAddr?: string\n}\n\n/**\n * @deprecated Use `algorand.account.getInformation(sender)` or `new AccountManager(clientManager).getInformation(sender)` instead.\n *\n * Returns the given sender account's current status, balance and spendable amounts.\n *\n * @example\n * ```typescript\n * const address = \"XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA\";\n * const accountInfo = await account.getInformation(address, algod);\n * ```\n *\n * [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountinformation)\n * @param sender The address of the sender/account to look up\n * @param algod The algod instance\n * @returns The account information\n */\nexport async function getAccountInformation(sender: string | SendTransactionFrom, algod: Algodv2): Promise<AccountInformation> {\n  const account = await algod.accountInformation(getSenderAddress(sender)).do()\n\n  return {\n    ...account,\n    address: account.address.toString(),\n    authAddr: account.authAddr ? account.authAddr.toString() : undefined,\n    // None of these can practically overflow 2^53\n    amount: Number(account.amount),\n    amountWithoutPendingRewards: Number(account.amountWithoutPendingRewards),\n    minBalance: Number(account.minBalance),\n    pendingRewards: Number(account.pendingRewards),\n    rewards: Number(account.rewards),\n    round: Number(account.round),\n    totalAppsOptedIn: Number(account.totalAppsOptedIn),\n    totalAssetsOptedIn: Number(account.totalAssetsOptedIn),\n    totalCreatedApps: Number(account.totalCreatedApps),\n    totalCreatedAssets: Number(account.totalCreatedAssets),\n    appsTotalExtraPages: account.appsTotalExtraPages !== undefined ? Number(account.appsTotalExtraPages) : undefined,\n    rewardBase: account.rewardBase !== undefined ? Number(account.rewardBase) : undefined,\n    totalBoxBytes: account.totalBoxBytes !== undefined ? Number(account.totalBoxBytes) : undefined,\n    totalBoxes: account.totalBoxes !== undefined ? Number(account.totalBoxes) : undefined,\n    lastHeartbeat: account.lastHeartbeat !== undefined ? Number(account.lastHeartbeat) : undefined,\n    lastProposed: account.lastProposed !== undefined ? Number(account.lastProposed) : undefined,\n  }\n}\n\n/**\n * @deprecated Use `algorand.asset.getAccountInformation(sender, assetId)` or `new AssetManager(...).getAccountInformation(sender, assetId)` instead.\n *\n * Returns the given sender account's asset holding for a given asset.\n *\n * @example\n * ```typescript\n * const address = \"XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA\";\n * const assetId = 123345;\n * const accountInfo = await account.getAccountAssetInformation(address, assetId, algod);\n * ```\n *\n * [Response data schema details](https://dev.algorand.co/reference/rest-apis/algod/#accountassetinformation)\n * @param sender The address of the sender/account to look up\n * @param assetId The ID of the asset to return a holding for\n * @param algod The algod instance\n * @returns The account asset holding information\n */\nexport async function getAccountAssetInformation(\n  sender: string | SendTransactionFrom,\n  assetId: number | bigint,\n  algod: Algodv2,\n): Promise<AccountAssetInformation> {\n  return AlgorandClient.fromClients({ algod }).asset.getAccountInformation(getSenderAddress(sender), BigInt(assetId))\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"account.mjs","names":[],"sources":["../../src/account/account.ts"],"sourcesContent":["import algosdk, { Address } from 'algosdk'\nimport { getSenderAddress } from '../transaction/transaction'\nimport { AccountAssetInformation, MultisigAccount, SigningAccount, TransactionSignerAccount } from '../types/account'\nimport { AccountManager } from '../types/account-manager'\nimport { AlgorandClient } from '../types/algorand-client'\nimport { AlgoAmount } from '../types/amount'\nimport { ClientManager } from '../types/client-manager'\nimport { SendTransactionFrom } from '../types/transaction'\nimport Account = algosdk.Account\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\nimport MultisigMetadata = algosdk.MultisigMetadata\nimport TransactionSigner = algosdk.TransactionSigner\nimport AccountInformationModel = algosdk.modelsv2.Account\n\n/**\n * @deprecated Use `algorand.account.multisig(multisigParams, signingAccounts)` or `new MultisigAccount(multisigParams, signingAccounts)` instead.\n *\n * Returns an account wrapper that supports partial or full multisig signing.\n * @param multisigParams The parameters that define the multisig account\n * @param signingAccounts The signers that are currently present\n * @returns A multisig account wrapper\n */\nexport function multisigAccount(multisigParams: MultisigMetadata, signingAccounts: (Account | SigningAccount)[]) {\n  return new MultisigAccount(multisigParams, signingAccounts)\n}\n\n/**\n * @deprecated Use `algorand.account.rekeyed(sender, account)` or `new SigningAccount(account, sender)` instead.\n *\n * Returns an account wrapper that supports a rekeyed account.\n * @param signer The account, with private key loaded, that is signing\n * @param sender The address of the rekeyed account that will act as a sender\n * @returns The SigningAccount wrapper\n */\nexport function rekeyedAccount(signer: Account, sender: string) {\n  return new SigningAccount(signer, sender)\n}\n\n/**\n * @deprecated Use `algorand.account.getSigner(sender)` (after previously registering the signer with `setSigner`) or `{ addr: sender, signer }` instead.\n *\n * Returns an account wrapper that supports a transaction signer with associated sender address.\n * @param signer The transaction signer\n * @param sender The address of sender account\n * @returns The SigningAccount wrapper\n */\nexport function transactionSignerAccount(signer: TransactionSigner, sender: string): TransactionSignerAccount {\n  return { addr: Address.fromString(sender), signer }\n}\n\n/**\n * @deprecated Use `algorand.account.random()` or `algosdk.generateAccount()` instead.\n *\n * Returns a new, random Algorand account with secret key loaded.\n *\n * This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.\n *\n */\nexport function randomAccount(): Account {\n  // This method is confusingly named, so this function provides a more dev friendly \"wrapper\" name\n  return algosdk.generateAccount()\n}\n\n/**\n * @deprecated Use `algorand.account.fromEnvironment(name, fundWith)` or `new AccountManager(clientManager).fromEnvironment()` instead.\n *\n * Returns an Algorand account with private key loaded by convention from environment variables 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.MY_ACCOUNT_MNEMONIC` then you can call the following to get that private key loaded into an account object:\n * ```typescript\n * const account = await mnemonicAccountFromEnvironment('MY_ACCOUNT', algod)\n * ```\n *\n * If that code runs against LocalNet then a wallet called `MY_ACCOUNT` will automatically be created with an account that is automatically funded with 1000 (default) ALGO from the default LocalNet dispenser.\n * If not running against LocalNet then it will use proces.env.MY_ACCOUNT_MNEMONIC as the private key and (if present) process.env.MY_ACCOUNT_SENDER as the sender address.\n *\n * @param account The details of the account to get, either the name identifier (string) or an object with:\n *   * `name`: string: 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 mnemonicAccountFromEnvironment(\n  account: string | { name: string; fundWith?: AlgoAmount },\n  algod: Algodv2,\n  kmdClient?: Kmd,\n): Promise<Account | SigningAccount> {\n  return (\n    await new AccountManager(new ClientManager({ algod, kmd: kmdClient })).fromEnvironment(\n      typeof account === 'string' ? account : account.name,\n      typeof account === 'string' ? undefined : account.fundWith,\n    )\n  ).account\n}\n\n/**\n * @deprecated Use `algosdk.decodeAddress` instead.\n *\n * Returns an account's address as a byte array\n *\n * @param account Either an account (with private key loaded) or the string address of an account\n */\nexport function getAccountAddressAsUint8Array(account: SendTransactionFrom | string) {\n  return algosdk.decodeAddress(typeof account === 'string' ? account : getSenderAddress(account)).publicKey\n}\n\n/**\n * @deprecated Use `algosdk.encodeAddress` instead.\n *\n * Returns the string address of an Algorand account from a base64 encoded version of the underlying byte array of the address public key\n *\n * @param addressEncodedInB64 The base64 encoded version of the underlying byte array of the address public key\n */\nexport function getAccountAddressAsString(addressEncodedInB64: string): string {\n  return algosdk.encodeAddress(Buffer.from(addressEncodedInB64, 'base64'))\n}\n\nexport type NumberConverter<T extends AccountInformationModel> = { [key in keyof T]: ToNumberIfExtends<T[key], number | bigint> }\ntype ToNumberIfExtends<K, E> = K extends E ? number : K\n/** @deprecated Account information at a given round. */\nexport type AccountInformation = Omit<NumberConverter<AccountInformationModel>, 'getEncodingSchema' | 'toEncodingData' | 'authAddr'> & {\n  /** (spend) the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field. */\n  authAddr?: string\n}\n\n/**\n * @deprecated Use `algorand.account.getInformation(sender)` or `new AccountManager(clientManager).getInformation(sender)` instead.\n *\n * Returns the given sender account's current status, balance and spendable amounts.\n *\n * @example\n * ```typescript\n * const address = \"XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA\";\n * const accountInfo = await account.getInformation(address, algod);\n * ```\n *\n * [Response data schema details](https://dev.algorand.co/reference/rest-api/algod/operations/accountinformation/)\n * @param sender The address of the sender/account to look up\n * @param algod The algod instance\n * @returns The account information\n */\nexport async function getAccountInformation(sender: string | SendTransactionFrom, algod: Algodv2): Promise<AccountInformation> {\n  const account = await algod.accountInformation(getSenderAddress(sender)).do()\n\n  return {\n    ...account,\n    address: account.address.toString(),\n    authAddr: account.authAddr ? account.authAddr.toString() : undefined,\n    // None of these can practically overflow 2^53\n    amount: Number(account.amount),\n    amountWithoutPendingRewards: Number(account.amountWithoutPendingRewards),\n    minBalance: Number(account.minBalance),\n    pendingRewards: Number(account.pendingRewards),\n    rewards: Number(account.rewards),\n    round: Number(account.round),\n    totalAppsOptedIn: Number(account.totalAppsOptedIn),\n    totalAssetsOptedIn: Number(account.totalAssetsOptedIn),\n    totalCreatedApps: Number(account.totalCreatedApps),\n    totalCreatedAssets: Number(account.totalCreatedAssets),\n    appsTotalExtraPages: account.appsTotalExtraPages !== undefined ? Number(account.appsTotalExtraPages) : undefined,\n    rewardBase: account.rewardBase !== undefined ? Number(account.rewardBase) : undefined,\n    totalBoxBytes: account.totalBoxBytes !== undefined ? Number(account.totalBoxBytes) : undefined,\n    totalBoxes: account.totalBoxes !== undefined ? Number(account.totalBoxes) : undefined,\n    lastHeartbeat: account.lastHeartbeat !== undefined ? Number(account.lastHeartbeat) : undefined,\n    lastProposed: account.lastProposed !== undefined ? Number(account.lastProposed) : undefined,\n  }\n}\n\n/**\n * @deprecated Use `algorand.asset.getAccountInformation(sender, assetId)` or `new AssetManager(...).getAccountInformation(sender, assetId)` instead.\n *\n * Returns the given sender account's asset holding for a given asset.\n *\n * @example\n * ```typescript\n * const address = \"XBYLS2E6YI6XXL5BWCAMOA4GTWHXWENZMX5UHXMRNWWUQ7BXCY5WC5TEPA\";\n * const assetId = 123345;\n * const accountInfo = await account.getAccountAssetInformation(address, assetId, algod);\n * ```\n *\n * [Response data schema details](https://dev.algorand.co/reference/rest-api/algod/operations/accountassetinformation/)\n * @param sender The address of the sender/account to look up\n * @param assetId The ID of the asset to return a holding for\n * @param algod The algod instance\n * @returns The account asset holding information\n */\nexport async function getAccountAssetInformation(\n  sender: string | SendTransactionFrom,\n  assetId: number | bigint,\n  algod: Algodv2,\n): Promise<AccountAssetInformation> {\n  return AlgorandClient.fromClients({ algod }).asset.getAccountInformation(getSenderAddress(sender), BigInt(assetId))\n}\n"],"mappings":";;;;;;;;;;;;;;;AAuBA,SAAgB,gBAAgB,gBAAkC,iBAA+C;CAC/G,OAAO,IAAI,gBAAgB,gBAAgB,eAAe;AAC5D;;;;;;;;;AAUA,SAAgB,eAAe,QAAiB,QAAgB;CAC9D,OAAO,IAAI,eAAe,QAAQ,MAAM;AAC1C;;;;;;;;;AAUA,SAAgB,yBAAyB,QAA2B,QAA0C;CAC5G,OAAO;EAAE,MAAM,QAAQ,WAAW,MAAM;EAAG;CAAO;AACpD;;;;;;;;;AAUA,SAAgB,gBAAyB;CAEvC,OAAO,QAAQ,gBAAgB;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,eAAsB,+BACpB,SACA,OACA,WACmC;CACnC,QACE,MAAM,IAAI,eAAe,IAAI,cAAc;EAAE;EAAO,KAAK;CAAU,CAAC,CAAC,CAAC,CAAC,gBACrE,OAAO,YAAY,WAAW,UAAU,QAAQ,MAChD,OAAO,YAAY,WAAW,KAAA,IAAY,QAAQ,QACpD,EAAA,CACA;AACJ;;;;;;;;AASA,SAAgB,8BAA8B,SAAuC;CACnF,OAAO,QAAQ,cAAc,OAAO,YAAY,WAAW,UAAU,iBAAiB,OAAO,CAAC,CAAC,CAAC;AAClG;;;;;;;;AASA,SAAgB,0BAA0B,qBAAqC;CAC7E,OAAO,QAAQ,cAAc,OAAO,KAAK,qBAAqB,QAAQ,CAAC;AACzE;;;;;;;;;;;;;;;;;AA0BA,eAAsB,sBAAsB,QAAsC,OAA6C;CAC7H,MAAM,UAAU,MAAM,MAAM,mBAAmB,iBAAiB,MAAM,CAAC,CAAC,CAAC,GAAG;CAE5E,OAAO;EACL,GAAG;EACH,SAAS,QAAQ,QAAQ,SAAS;EAClC,UAAU,QAAQ,WAAW,QAAQ,SAAS,SAAS,IAAI,KAAA;EAE3D,QAAQ,OAAO,QAAQ,MAAM;EAC7B,6BAA6B,OAAO,QAAQ,2BAA2B;EACvE,YAAY,OAAO,QAAQ,UAAU;EACrC,gBAAgB,OAAO,QAAQ,cAAc;EAC7C,SAAS,OAAO,QAAQ,OAAO;EAC/B,OAAO,OAAO,QAAQ,KAAK;EAC3B,kBAAkB,OAAO,QAAQ,gBAAgB;EACjD,oBAAoB,OAAO,QAAQ,kBAAkB;EACrD,kBAAkB,OAAO,QAAQ,gBAAgB;EACjD,oBAAoB,OAAO,QAAQ,kBAAkB;EACrD,qBAAqB,QAAQ,wBAAwB,KAAA,IAAY,OAAO,QAAQ,mBAAmB,IAAI,KAAA;EACvG,YAAY,QAAQ,eAAe,KAAA,IAAY,OAAO,QAAQ,UAAU,IAAI,KAAA;EAC5E,eAAe,QAAQ,kBAAkB,KAAA,IAAY,OAAO,QAAQ,aAAa,IAAI,KAAA;EACrF,YAAY,QAAQ,eAAe,KAAA,IAAY,OAAO,QAAQ,UAAU,IAAI,KAAA;EAC5E,eAAe,QAAQ,kBAAkB,KAAA,IAAY,OAAO,QAAQ,aAAa,IAAI,KAAA;EACrF,cAAc,QAAQ,iBAAiB,KAAA,IAAY,OAAO,QAAQ,YAAY,IAAI,KAAA;CACpF;AACF;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,2BACpB,QACA,SACA,OACkC;CAClC,OAAO,eAAe,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,sBAAsB,iBAAiB,MAAM,GAAG,OAAO,OAAO,CAAC;AACpH"}

package/account/get-account-config-from-environment.d.ts

@@ -1,4 +1,6 @@
-import { AccountConfig } from '../types/account';
+import { AccountConfig } from "../types/account.js";
+
+//#region src/account/get-account-config-from-environment.d.ts
 /**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function
  * Returns the Account configuration from environment variables
  *
@@ -9,4 +11,7 @@ import { AccountConfig } from '../types/account';
  * {accountName}_SENDER
  *
  */
-export declare function getAccountConfigFromEnvironment(accountName: string): AccountConfig;
+declare function getAccountConfigFromEnvironment(accountName: string): AccountConfig;
+//#endregion
+export { getAccountConfigFromEnvironment };
+//# sourceMappingURL=get-account-config-from-environment.d.ts.map

package/account/get-account-config-from-environment.js

@@ -1,25 +1,23 @@
-'use strict';
-
+//#region src/account/get-account-config-from-environment.ts
 /**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function
- * Returns the Account configuration from environment variables
- *
- * @param accountName account name
- *
- * @example environment variables
- * {accountName}_MNEMONIC
- * {accountName}_SENDER
- *
- */
+* Returns the Account configuration from environment variables
+*
+* @param accountName account name
+*
+* @example environment variables
+* {accountName}_MNEMONIC
+* {accountName}_SENDER
+*
+*/
 function getAccountConfigFromEnvironment(accountName) {
-    if (!process || !process.env) {
-        throw new Error('Attempt to get account with private key from a non Node.js context; not supported!');
-    }
-    return {
-        accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',
-        senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],
-        accountName,
-    };
+	if (!process || !process.env) throw new Error("Attempt to get account with private key from a non Node.js context; not supported!");
+	return {
+		accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || "",
+		senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],
+		accountName
+	};
 }
-
+//#endregion
 exports.getAccountConfigFromEnvironment = getAccountConfigFromEnvironment;
-//# sourceMappingURL=get-account-config-from-environment.js.map
+
+//# sourceMappingURL=get-account-config-from-environment.js.map

package/account/get-account-config-from-environment.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-account-config-from-environment.js","sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":["import { AccountConfig } from '../types/account'\n\n/**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function\n * Returns the Account configuration from environment variables\n *\n * @param accountName account name\n *\n * @example environment variables\n * {accountName}_MNEMONIC\n * {accountName}_SENDER\n *\n */\nexport function getAccountConfigFromEnvironment(accountName: string): AccountConfig {\n  if (!process || !process.env) {\n    throw new Error('Attempt to get account with private key from a non Node.js context; not supported!')\n  }\n\n  return {\n    accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',\n    senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],\n    accountName,\n  }\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;AASG;AACG,SAAU,+BAA+B,CAAC,WAAmB,EAAA;IACjE,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE;AAC5B,QAAA,MAAM,IAAI,KAAK,CAAC,oFAAoF,CAAC;;IAGvG,OAAO;AACL,QAAA,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,CAAC,WAAW,EAAE,CAAW,SAAA,CAAA,CAAC,IAAI,EAAE;QAC3E,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAG,EAAA,WAAW,CAAC,WAAW,EAAE,CAAA,OAAA,CAAS,CAAC;QACjE,WAAW;KACZ;AACH;;;;"}
+{"version":3,"file":"get-account-config-from-environment.js","names":[],"sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":["import { AccountConfig } from '../types/account'\n\n/**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function\n * Returns the Account configuration from environment variables\n *\n * @param accountName account name\n *\n * @example environment variables\n * {accountName}_MNEMONIC\n * {accountName}_SENDER\n *\n */\nexport function getAccountConfigFromEnvironment(accountName: string): AccountConfig {\n  if (!process || !process.env) {\n    throw new Error('Attempt to get account with private key from a non Node.js context; not supported!')\n  }\n\n  return {\n    accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',\n    senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],\n    accountName,\n  }\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,gCAAgC,aAAoC;CAClF,IAAI,CAAC,WAAW,CAAC,QAAQ,KACvB,MAAM,IAAI,MAAM,oFAAoF;CAGtG,OAAO;EACL,iBAAiB,QAAQ,IAAI,GAAG,YAAY,YAAY,EAAE,eAAe;EACzE,eAAe,QAAQ,IAAI,GAAG,YAAY,YAAY,EAAE;EACxD;CACF;AACF"}

package/account/get-account-config-from-environment.mjs

@@ -1,23 +1,23 @@
+//#region src/account/get-account-config-from-environment.ts
 /**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function
- * Returns the Account configuration from environment variables
- *
- * @param accountName account name
- *
- * @example environment variables
- * {accountName}_MNEMONIC
- * {accountName}_SENDER
- *
- */
+* Returns the Account configuration from environment variables
+*
+* @param accountName account name
+*
+* @example environment variables
+* {accountName}_MNEMONIC
+* {accountName}_SENDER
+*
+*/
 function getAccountConfigFromEnvironment(accountName) {
-    if (!process || !process.env) {
-        throw new Error('Attempt to get account with private key from a non Node.js context; not supported!');
-    }
-    return {
-        accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',
-        senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],
-        accountName,
-    };
+	if (!process || !process.env) throw new Error("Attempt to get account with private key from a non Node.js context; not supported!");
+	return {
+		accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || "",
+		senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],
+		accountName
+	};
 }
-
+//#endregion
 export { getAccountConfigFromEnvironment };
-//# sourceMappingURL=get-account-config-from-environment.mjs.map
+
+//# sourceMappingURL=get-account-config-from-environment.mjs.map

package/account/get-account-config-from-environment.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"get-account-config-from-environment.mjs","sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":["import { AccountConfig } from '../types/account'\n\n/**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function\n * Returns the Account configuration from environment variables\n *\n * @param accountName account name\n *\n * @example environment variables\n * {accountName}_MNEMONIC\n * {accountName}_SENDER\n *\n */\nexport function getAccountConfigFromEnvironment(accountName: string): AccountConfig {\n  if (!process || !process.env) {\n    throw new Error('Attempt to get account with private key from a non Node.js context; not supported!')\n  }\n\n  return {\n    accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',\n    senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],\n    accountName,\n  }\n}\n"],"names":[],"mappings":"AAEA;;;;;;;;;AASG;AACG,SAAU,+BAA+B,CAAC,WAAmB,EAAA;IACjE,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE;AAC5B,QAAA,MAAM,IAAI,KAAK,CAAC,oFAAoF,CAAC;;IAGvG,OAAO;AACL,QAAA,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,CAAC,WAAW,EAAE,CAAW,SAAA,CAAA,CAAC,IAAI,EAAE;QAC3E,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAG,EAAA,WAAW,CAAC,WAAW,EAAE,CAAA,OAAA,CAAS,CAAC;QACjE,WAAW;KACZ;AACH;;;;"}
+{"version":3,"file":"get-account-config-from-environment.mjs","names":[],"sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":["import { AccountConfig } from '../types/account'\n\n/**  @deprecated Use algokit.mnemonicAccountFromEnvironment, which doesn't need this function\n * Returns the Account configuration from environment variables\n *\n * @param accountName account name\n *\n * @example environment variables\n * {accountName}_MNEMONIC\n * {accountName}_SENDER\n *\n */\nexport function getAccountConfigFromEnvironment(accountName: string): AccountConfig {\n  if (!process || !process.env) {\n    throw new Error('Attempt to get account with private key from a non Node.js context; not supported!')\n  }\n\n  return {\n    accountMnemonic: process.env[`${accountName.toUpperCase()}_MNEMONIC`] || '',\n    senderAddress: process.env[`${accountName.toUpperCase()}_SENDER`],\n    accountName,\n  }\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,gCAAgC,aAAoC;CAClF,IAAI,CAAC,WAAW,CAAC,QAAQ,KACvB,MAAM,IAAI,MAAM,oFAAoF;CAGtG,OAAO;EACL,iBAAiB,QAAQ,IAAI,GAAG,YAAY,YAAY,EAAE,eAAe;EACzE,eAAe,QAAQ,IAAI,GAAG,YAAY,YAAY,EAAE;EACxD;CACF;AACF"}

package/account/get-account.d.ts

@@ -1,9 +1,8 @@
-import algosdk from 'algosdk';
-import { AccountConfig, SigningAccount } from '../types/account';
-import { AlgoAmount } from '../types/amount';
-import Account = algosdk.Account;
-import Algodv2 = algosdk.Algodv2;
-import Kmd = algosdk.Kmd;
+import { AlgoAmount } from "../types/amount.js";
+import { AccountConfig, SigningAccount } from "../types/account.js";
+import algosdk from "algosdk";
+
+//#region src/account/get-account.d.ts
 /**  @deprecated use `algorand.account.fromEnvironment()` instead
  *
  * Returns an Algorand account with private key loaded by convention based on the given name identifier.
@@ -34,9 +33,9 @@ import Kmd = algosdk.Kmd;
  * @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)
  */
-export declare function getAccount(account: {
-    name: string;
-    fundWith?: AlgoAmount;
+declare function getAccount(account: {
+  name: string;
+  fundWith?: AlgoAmount;
 } | string, algod: Algodv2, kmdClient?: Kmd): Promise<Account | SigningAccount>;
 /**  @deprecated use `algorand.account.fromEnvironment()` instead
  * Returns an Algorand account with private key loaded by convention based on the given name identifier.
@@ -59,7 +58,10 @@ export declare function getAccount(account: {
  * @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)
  */
-export declare function getAccount(account: {
-    config: AccountConfig;
-    fundWith?: AlgoAmount;
+declare function getAccount(account: {
+  config: AccountConfig;
+  fundWith?: AlgoAmount;
 }, algod: Algodv2, kmdClient?: Kmd): Promise<Account | SigningAccount>;
+//#endregion
+export { getAccount };
+//# sourceMappingURL=get-account.d.ts.map