@algorandfoundation/algokit-utils 5.3.3-beta.2 → 5.4.0-beta.1

package/account/account.d.ts

@@ -0,0 +1,81 @@
+import algosdk from 'algosdk';
+import { MultisigAccount, SigningAccount, TransactionSignerAccount } from '../types/account';
+import { AlgoAmount } from '../types/amount';
+import { SendTransactionFrom } from '../types/transaction';
+import Account = algosdk.Account;
+import Algodv2 = algosdk.Algodv2;
+import Kmd = algosdk.Kmd;
+import MultisigMetadata = algosdk.MultisigMetadata;
+import TransactionSigner = algosdk.TransactionSigner;
+/**
+ * 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
+ */
+export declare function multisigAccount(multisigParams: MultisigMetadata, signingAccounts: (Account | SigningAccount)[]): MultisigAccount;
+/**
+ * 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
+ */
+export declare function rekeyedAccount(signer: Account, sender: string): SigningAccount;
+/**
+ * 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
+ */
+export declare function transactionSignerAccount(signer: TransactionSigner, sender: string): TransactionSignerAccount;
+/** Returns a new, random Algorand account with secret key loaded.
+ *
+ * This is a wrapper around algosdk.generateAccount to provide a more friendly/obvious name.
+ *
+ */
+export declare function randomAccount(): Account;
+/**
+ * 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) ALGOs 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 Algos 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)
+ */
+export declare function mnemonicAccountFromEnvironment(account: string | {
+    name: string;
+    fundWith?: AlgoAmount;
+}, algod: Algodv2, kmdClient?: Kmd): Promise<Account | SigningAccount>;
+/** 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
+ */
+export declare function getAccountAddressAsUint8Array(account: SendTransactionFrom | string): Uint8Array;
+/** 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
+ */
+export declare function getAccountAddressAsString(addressEncodedInB64: string): string;
+//# sourceMappingURL=account.d.ts.map

package/account/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/account/account.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAK7B,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG1D,OAAO,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;AAChC,OAAO,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;AAChC,OAAO,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;AACxB,OAAO,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAA;AAClD,OAAO,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAA;AAEpD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAC,OAAO,GAAG,cAAc,CAAC,EAAE,mBAE9G;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,kBAE7D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,wBAAwB,CAE5G;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAGvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,EACzD,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,GAAG,cAAc,CAAC,CAsBnC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,cAElF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,mBAAmB,EAAE,MAAM,GAAG,MAAM,CAE7E"}

package/account/account.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var algosdk = require('algosdk');
+var config = require('../config.js');
+var getOrCreateKmdWalletAccount = require('../localnet/get-or-create-kmd-wallet-account.js');
+var isLocalnet = require('../localnet/is-localnet.js');
+var transaction = require('../transaction/transaction.js');
+var account = require('../types/account.js');
+var getAccountConfigFromEnvironment = require('./get-account-config-from-environment.js');
+var mnemonicAccount = require('./mnemonic-account.js');
+
+/**
+ * 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 account.MultisigAccount(multisigParams, signingAccounts);
+}
+/**
+ * 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 account.SigningAccount(signer, sender);
+}
+/**
+ * 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: sender, signer };
+}
+/** 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();
+}
+/**
+ * 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) ALGOs 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 Algos 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$1, algod, kmdClient) {
+    const { name, fundWith } = typeof account$1 === 'string' ? { name: account$1, fundWith: undefined } : account$1;
+    // todo: When eventually removing this method, inline it here
+    const config$1 = getAccountConfigFromEnvironment.getAccountConfigFromEnvironment(name);
+    if (config$1.accountMnemonic) {
+        const signer = mnemonicAccount.mnemonicAccount(config$1.accountMnemonic);
+        const sender = config$1.senderAddress;
+        if (sender) {
+            config.Config.logger.debug(`Using rekeyed account ${signer.addr} for sender ${sender} for ${name} account`);
+            return new account.SigningAccount(signer, sender);
+        }
+        else {
+            return signer;
+        }
+    }
+    if (await isLocalnet.isLocalNet(algod)) {
+        return await getOrCreateKmdWalletAccount.getOrCreateKmdWalletAccount({ name, fundWith }, algod, kmdClient);
+    }
+    throw new Error(`Missing environment variable ${name.toUpperCase()}_MNEMONIC when looking for account ${name}`);
+}
+/** 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 : transaction.getSenderAddress(account)).publicKey;
+}
+/** 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'));
+}
+
+exports.getAccountAddressAsString = getAccountAddressAsString;
+exports.getAccountAddressAsUint8Array = getAccountAddressAsUint8Array;
+exports.mnemonicAccountFromEnvironment = mnemonicAccountFromEnvironment;
+exports.multisigAccount = multisigAccount;
+exports.randomAccount = randomAccount;
+exports.rekeyedAccount = rekeyedAccount;
+exports.transactionSignerAccount = transactionSignerAccount;
+//# sourceMappingURL=account.js.map

package/account/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sources":["../../src/account/account.ts"],"sourcesContent":[null],"names":["MultisigAccount","SigningAccount","account","config","getAccountConfigFromEnvironment","mnemonicAccount","Config","isLocalNet","getOrCreateKmdWalletAccount","getSenderAddress"],"mappings":";;;;;;;;;;;AAgBA;;;;;AAKG;AACa,SAAA,eAAe,CAAC,cAAgC,EAAE,eAA6C,EAAA;AAC7G,IAAA,OAAO,IAAIA,uBAAe,CAAC,cAAc,EAAE,eAAe,CAAC,CAAA;AAC7D,CAAC;AAED;;;;;AAKG;AACa,SAAA,cAAc,CAAC,MAAe,EAAE,MAAc,EAAA;AAC5D,IAAA,OAAO,IAAIC,sBAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;AAKG;AACa,SAAA,wBAAwB,CAAC,MAAyB,EAAE,MAAc,EAAA;AAChF,IAAA,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;AACjC,CAAC;AAED;;;;AAIG;SACa,aAAa,GAAA;;AAE3B,IAAA,OAAO,OAAO,CAAC,eAAe,EAAE,CAAA;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI,eAAe,8BAA8B,CAClDC,SAAyD,EACzD,KAAc,EACd,SAAe,EAAA;IAEf,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,OAAOA,SAAO,KAAK,QAAQ,GAAG,EAAE,IAAI,EAAEA,SAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAGA,SAAO,CAAA;;AAGzG,IAAA,MAAMC,QAAM,GAAGC,+DAA+B,CAAC,IAAI,CAAC,CAAA;AAEpD,IAAA,IAAID,QAAM,CAAC,eAAe,EAAE;QAC1B,MAAM,MAAM,GAAGE,+BAAe,CAACF,QAAM,CAAC,eAAe,CAAC,CAAA;AACtD,QAAA,MAAM,MAAM,GAAGA,QAAM,CAAC,aAAa,CAAA;QACnC,IAAI,MAAM,EAAE;AACV,YAAAG,aAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAyB,sBAAA,EAAA,MAAM,CAAC,IAAI,eAAe,MAAM,CAAA,KAAA,EAAQ,IAAI,CAAA,QAAA,CAAU,CAAC,CAAA;AACpG,YAAA,OAAO,IAAIL,sBAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAC1C;aAAM;AACL,YAAA,OAAO,MAAM,CAAA;SACd;KACF;AAED,IAAA,IAAI,MAAMM,qBAAU,CAAC,KAAK,CAAC,EAAE;AAC3B,QAAA,OAAO,MAAMC,uDAA2B,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;KAC/E;AAED,IAAA,MAAM,IAAI,KAAK,CAAC,CAAA,6BAAA,EAAgC,IAAI,CAAC,WAAW,EAAE,CAAsC,mCAAA,EAAA,IAAI,CAAE,CAAA,CAAC,CAAA;AACjH,CAAC;AAED;;;AAGG;AACG,SAAU,6BAA6B,CAAC,OAAqC,EAAA;IACjF,OAAO,OAAO,CAAC,aAAa,CAAC,OAAO,OAAO,KAAK,QAAQ,GAAG,OAAO,GAAGC,4BAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAA;AAC3G,CAAC;AAED;;;AAGG;AACG,SAAU,yBAAyB,CAAC,mBAA2B,EAAA;AACnE,IAAA,OAAO,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC1E;;;;;;;;;;"}

package/account/account.mjs

@@ -0,0 +1,112 @@
+import algosdk from 'algosdk';
+import { Config } from '../config.mjs';
+import { getOrCreateKmdWalletAccount } from '../localnet/get-or-create-kmd-wallet-account.mjs';
+import { isLocalNet } from '../localnet/is-localnet.mjs';
+import { getSenderAddress } from '../transaction/transaction.mjs';
+import { MultisigAccount, SigningAccount } from '../types/account.mjs';
+import { getAccountConfigFromEnvironment } from './get-account-config-from-environment.mjs';
+import { mnemonicAccount } from './mnemonic-account.mjs';
+
+/**
+ * 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);
+}
+/**
+ * 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);
+}
+/**
+ * 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: sender, signer };
+}
+/** 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();
+}
+/**
+ * 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) ALGOs 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 Algos 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) {
+    const { name, fundWith } = typeof account === 'string' ? { name: account, fundWith: undefined } : account;
+    // todo: When eventually removing this method, inline it here
+    const config = getAccountConfigFromEnvironment(name);
+    if (config.accountMnemonic) {
+        const signer = mnemonicAccount(config.accountMnemonic);
+        const sender = config.senderAddress;
+        if (sender) {
+            Config.logger.debug(`Using rekeyed account ${signer.addr} for sender ${sender} for ${name} account`);
+            return new SigningAccount(signer, sender);
+        }
+        else {
+            return signer;
+        }
+    }
+    if (await isLocalNet(algod)) {
+        return await getOrCreateKmdWalletAccount({ name, fundWith }, algod, kmdClient);
+    }
+    throw new Error(`Missing environment variable ${name.toUpperCase()}_MNEMONIC when looking for account ${name}`);
+}
+/** 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;
+}
+/** 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'));
+}
+
+export { getAccountAddressAsString, getAccountAddressAsUint8Array, mnemonicAccountFromEnvironment, multisigAccount, randomAccount, rekeyedAccount, transactionSignerAccount };
+//# sourceMappingURL=account.mjs.map

package/account/account.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.mjs","sources":["../../src/account/account.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAgBA;;;;;AAKG;AACa,SAAA,eAAe,CAAC,cAAgC,EAAE,eAA6C,EAAA;AAC7G,IAAA,OAAO,IAAI,eAAe,CAAC,cAAc,EAAE,eAAe,CAAC,CAAA;AAC7D,CAAC;AAED;;;;;AAKG;AACa,SAAA,cAAc,CAAC,MAAe,EAAE,MAAc,EAAA;AAC5D,IAAA,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;AAKG;AACa,SAAA,wBAAwB,CAAC,MAAyB,EAAE,MAAc,EAAA;AAChF,IAAA,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;AACjC,CAAC;AAED;;;;AAIG;SACa,aAAa,GAAA;;AAE3B,IAAA,OAAO,OAAO,CAAC,eAAe,EAAE,CAAA;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI,eAAe,8BAA8B,CAClD,OAAyD,EACzD,KAAc,EACd,SAAe,EAAA;IAEf,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,OAAO,OAAO,KAAK,QAAQ,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;;AAGzG,IAAA,MAAM,MAAM,GAAG,+BAA+B,CAAC,IAAI,CAAC,CAAA;AAEpD,IAAA,IAAI,MAAM,CAAC,eAAe,EAAE;QAC1B,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,CAAA;AACtD,QAAA,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,CAAA;QACnC,IAAI,MAAM,EAAE;AACV,YAAA,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAyB,sBAAA,EAAA,MAAM,CAAC,IAAI,eAAe,MAAM,CAAA,KAAA,EAAQ,IAAI,CAAA,QAAA,CAAU,CAAC,CAAA;AACpG,YAAA,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAC1C;aAAM;AACL,YAAA,OAAO,MAAM,CAAA;SACd;KACF;AAED,IAAA,IAAI,MAAM,UAAU,CAAC,KAAK,CAAC,EAAE;AAC3B,QAAA,OAAO,MAAM,2BAA2B,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;KAC/E;AAED,IAAA,MAAM,IAAI,KAAK,CAAC,CAAA,6BAAA,EAAgC,IAAI,CAAC,WAAW,EAAE,CAAsC,mCAAA,EAAA,IAAI,CAAE,CAAA,CAAC,CAAA;AACjH,CAAC;AAED;;;AAGG;AACG,SAAU,6BAA6B,CAAC,OAAqC,EAAA;IACjF,OAAO,OAAO,CAAC,aAAa,CAAC,OAAO,OAAO,KAAK,QAAQ,GAAG,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAA;AAC3G,CAAC;AAED;;;AAGG;AACG,SAAU,yBAAyB,CAAC,mBAA2B,EAAA;AACnE,IAAA,OAAO,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC1E;;;;"}

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

@@ -0,0 +1,13 @@
+import { AccountConfig } from '../types/account';
+/**  @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
+ *
+ */
+export declare function getAccountConfigFromEnvironment(accountName: string): AccountConfig;
+//# sourceMappingURL=get-account-config-from-environment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-account-config-from-environment.d.ts","sourceRoot":"","sources":["../../src/account/get-account-config-from-environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAUlF"}

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

@@ -0,0 +1,25 @@
+'use strict';
+
+/**  @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
+ *
+ */
+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,
+    };
+}
+
+exports.getAccountConfigFromEnvironment = getAccountConfigFromEnvironment;
+//# sourceMappingURL=get-account-config-from-environment.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-account-config-from-environment.js","sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":[null],"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,CAAA;KACtG;IAED,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,CAAA;AACH;;;;"}

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

@@ -0,0 +1,23 @@
+/**  @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
+ *
+ */
+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,
+    };
+}
+
+export { getAccountConfigFromEnvironment };
+//# sourceMappingURL=get-account-config-from-environment.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-account-config-from-environment.mjs","sources":["../../src/account/get-account-config-from-environment.ts"],"sourcesContent":[null],"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,CAAA;KACtG;IAED,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,CAAA;AACH;;;;"}

package/account/get-account.d.ts

@@ -0,0 +1,66 @@
+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;
+/**  @deprecated use mnemonicAccountFromEnvironment 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('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) ALGOs from the default LocalNet dispenser.
+ *
+ * @param account The details of the account to get, either the name identifier (string) or an object with:
+ *   * `name`: 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 Algos 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)
+ */
+export declare function getAccount(account: {
+    name: string;
+    fundWith?: AlgoAmount;
+} | string, algod: Algodv2, kmdClient?: Kmd): Promise<Account | SigningAccount>;
+/**  @deprecated use mnemonicAccountFromEnvironment 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.
+ *
+ * @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) ALGOs from the default LocalNet dispenser.
+ *
+ * @param account The details of the account to get, an object with:
+ *   * `config`: Account configuration. To get from environment use getAccountConfigFromEnvironment(accountName)
+ *   * `fundWith`: The amount to fund the account with when it gets created (when targeting LocalNet), if not specified then 1000 Algos 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)
+ */
+export declare function getAccount(account: {
+    config: AccountConfig;
+    fundWith?: AlgoAmount;
+}, algod: Algodv2, kmdClient?: Kmd): Promise<Account | SigningAccount>;
+//# sourceMappingURL=get-account.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-account.d.ts","sourceRoot":"","sources":["../../src/account/get-account.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAI7B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAG5C,OAAO,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;AAChC,OAAO,OAAO,GAAG,OAAO,CAAC,OAAO,CAAA;AAChC,OAAO,GAAG,GAAG,OAAO,CAAC,GAAG,CAAA;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,GAAG,MAAM,EACzD,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,GAAG,cAAc,CAAC,CAAA;AAEpC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,EACzD,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,GAAG,cAAc,CAAC,CAAA"}

package/account/get-account.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var algosdk = require('algosdk');
+var config = require('../config.js');
+var getOrCreateKmdWalletAccount = require('../localnet/get-or-create-kmd-wallet-account.js');
+var isLocalnet = require('../localnet/is-localnet.js');
+var account = require('../types/account.js');
+var getAccountConfigFromEnvironment = require('./get-account-config-from-environment.js');
+var mnemonicAccount = require('./mnemonic-account.js');
+
+/**  @deprecated use mnemonicAccountFromEnvironment 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) ALGOs 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 Algos 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$1, algod, kmdClient) {
+    let name;
+    let fundWith = undefined;
+    let config$1;
+    if (typeof account$1 === 'string') {
+        name = account$1;
+        config$1 = getAccountConfigFromEnvironment.getAccountConfigFromEnvironment(name);
+    }
+    else if ('name' in account$1) {
+        name = account$1.name;
+        config$1 = getAccountConfigFromEnvironment.getAccountConfigFromEnvironment(name);
+        fundWith = account$1.fundWith;
+    }
+    else if ('config' in account$1) {
+        config$1 = account$1.config;
+        name = config$1.accountName;
+        fundWith = account$1.fundWith;
+    }
+    else {
+        throw new Error('Missing name or account config');
+    }
+    if (config$1.accountMnemonic) {
+        const signer = mnemonicAccount.mnemonicAccount(config$1.accountMnemonic);
+        const sender = config$1.senderAddress || config$1.senderMnemonic;
+        if (sender) {
+            config.Config.logger.debug(`Using rekeyed account ${signer.addr} for sender ${sender} for ${name} account`);
+            return new account.SigningAccount(signer, sender);
+        }
+        else {
+            return signer;
+        }
+    }
+    if (await isLocalnet.isLocalNet(algod)) {
+        const account = await getOrCreateKmdWalletAccount.getOrCreateKmdWalletAccount({ name, fundWith }, algod, kmdClient);
+        config$1.accountMnemonic = algosdk.secretKeyToMnemonic(account.sk);
+        return account;
+    }
+    throw new Error(`Missing environment variable ${name.toUpperCase()}_MNEMONIC when looking for account ${name}`);
+}
+
+exports.getAccount = getAccount;
+//# sourceMappingURL=get-account.js.map

package/account/get-account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-account.js","sources":["../../src/account/get-account.ts"],"sourcesContent":[null],"names":["account","config","getAccountConfigFromEnvironment","mnemonicAccount","Config","SigningAccount","isLocalNet","getOrCreateKmdWalletAccount"],"mappings":";;;;;;;;;;AA2EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACI,eAAe,UAAU,CAC9BA,SAA4G,EAC5G,KAAc,EACd,SAAe,EAAA;AAEf,IAAA,IAAI,IAAY,CAAA;IAChB,IAAI,QAAQ,GAA2B,SAAS,CAAA;AAChD,IAAA,IAAIC,QAAqB,CAAA;AAEzB,IAAA,IAAI,OAAOD,SAAO,KAAK,QAAQ,EAAE;QAC/B,IAAI,GAAGA,SAAO,CAAA;AACd,QAAAC,QAAM,GAAGC,+DAA+B,CAAC,IAAI,CAAC,CAAA;KAC/C;AAAM,SAAA,IAAI,MAAM,IAAIF,SAAO,EAAE;AAC5B,QAAA,IAAI,GAAGA,SAAO,CAAC,IAAI,CAAA;AACnB,QAAAC,QAAM,GAAGC,+DAA+B,CAAC,IAAI,CAAC,CAAA;AAC9C,QAAA,QAAQ,GAAGF,SAAO,CAAC,QAAQ,CAAA;KAC5B;AAAM,SAAA,IAAI,QAAQ,IAAIA,SAAO,EAAE;AAC9B,QAAAC,QAAM,GAAGD,SAAO,CAAC,MAAM,CAAA;AACvB,QAAA,IAAI,GAAGC,QAAM,CAAC,WAAW,CAAA;AACzB,QAAA,QAAQ,GAAGD,SAAO,CAAC,QAAQ,CAAA;KAC5B;SAAM;AACL,QAAA,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;KAClD;AAED,IAAA,IAAIC,QAAM,CAAC,eAAe,EAAE;QAC1B,MAAM,MAAM,GAAGE,+BAAe,CAACF,QAAM,CAAC,eAAe,CAAC,CAAA;QACtD,MAAM,MAAM,GAAGA,QAAM,CAAC,aAAa,IAAIA,QAAM,CAAC,cAAc,CAAA;QAC5D,IAAI,MAAM,EAAE;AACV,YAAAG,aAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAyB,sBAAA,EAAA,MAAM,CAAC,IAAI,eAAe,MAAM,CAAA,KAAA,EAAQ,IAAI,CAAA,QAAA,CAAU,CAAC,CAAA;AACpG,YAAA,OAAO,IAAIC,sBAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAC1C;aAAM;AACL,YAAA,OAAO,MAAM,CAAA;SACd;KACF;AAED,IAAA,IAAI,MAAMC,qBAAU,CAAC,KAAK,CAAC,EAAE;AAC3B,QAAA,MAAM,OAAO,GAAG,MAAMC,uDAA2B,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,CAAA;QACvFN,QAAM,CAAC,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;AAChE,QAAA,OAAO,OAAO,CAAA;KACf;AAED,IAAA,MAAM,IAAI,KAAK,CAAC,CAAA,6BAAA,EAAgC,IAAI,CAAC,WAAW,EAAE,CAAsC,mCAAA,EAAA,IAAI,CAAE,CAAA,CAAC,CAAA;AACjH;;;;"}