@algorandfoundation/algokit-utils 9.2.0 → 10.0.0-alpha.10

package/account/get-account.js.map

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

package/account/get-account.mjs

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

package/account/get-account.mjs.map

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

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

@@ -1,17 +0,0 @@
-import algosdk from 'algosdk';
-import Algodv2 = algosdk.Algodv2;
-import Kmd = algosdk.Kmd;
-/**
- * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
- *
- * Returns an account (with private key loaded) that can act as a dispenser
- *
- * If running on LocalNet then it will return the default dispenser account automatically,
- *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
- *
- * @param algod An algod client
- * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
- */
-export declare function getDispenserAccount(algod: Algodv2, kmd?: Kmd): Promise<algosdk.Address & import("../types/account").TransactionSignerAccount & {
-    account: import("../types/account").SigningAccount;
-}>;

package/account/get-dispenser-account.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var types_accountManager = require('../types/account-manager.js');
-var types_clientManager = require('../types/client-manager.js');
-
-/**
- * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
- *
- * Returns an account (with private key loaded) that can act as a dispenser
- *
- * If running on LocalNet then it will return the default dispenser account automatically,
- *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
- *
- * @param algod An algod client
- * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
- */
-async function getDispenserAccount(algod, kmd) {
-    return new types_accountManager.AccountManager(new types_clientManager.ClientManager({ algod, kmd })).dispenserFromEnvironment();
-}
-
-exports.getDispenserAccount = getDispenserAccount;
-//# sourceMappingURL=get-dispenser-account.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-dispenser-account.js","sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"names":["AccountManager","ClientManager"],"mappings":";;;;;AAOA;;;;;;;;;;AAUG;AACI,eAAe,mBAAmB,CAAC,KAAc,EAAE,GAAS,EAAA;AACjE,IAAA,OAAO,IAAIA,mCAAc,CAAC,IAAIC,iCAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,wBAAwB,EAAE;AACzF;;;;"}

package/account/get-dispenser-account.mjs

@@ -1,20 +0,0 @@
-import { AccountManager } from '../types/account-manager.mjs';
-import { ClientManager } from '../types/client-manager.mjs';
-
-/**
- * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead
- *
- * Returns an account (with private key loaded) that can act as a dispenser
- *
- * If running on LocalNet then it will return the default dispenser account automatically,
- *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC
- *
- * @param algod An algod client
- * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables
- */
-async function getDispenserAccount(algod, kmd) {
-    return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment();
-}
-
-export { getDispenserAccount };
-//# sourceMappingURL=get-dispenser-account.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-dispenser-account.mjs","sources":["../../src/account/get-dispenser-account.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AccountManager } from '../types/account-manager'\nimport { ClientManager } from '../types/client-manager'\n\nimport Algodv2 = algosdk.Algodv2\nimport Kmd = algosdk.Kmd\n\n/**\n * @deprecated Use `algorand.account.dispenserFromEnvironment()` or `new AccountManager(clientManager).dispenserFromEnvironment()` instead\n *\n * Returns an account (with private key loaded) that can act as a dispenser\n *\n * If running on LocalNet then it will return the default dispenser account automatically,\n *  otherwise it will load the account mnemonic stored in process.env.DISPENSER_MNEMONIC\n *\n * @param algod An algod client\n * @param kmd A KMD client, if not specified then a default KMD client will be loaded from environment variables\n */\nexport async function getDispenserAccount(algod: Algodv2, kmd?: Kmd) {\n  return new AccountManager(new ClientManager({ algod, kmd })).dispenserFromEnvironment()\n}\n"],"names":[],"mappings":";;;AAOA;;;;;;;;;;AAUG;AACI,eAAe,mBAAmB,CAAC,KAAc,EAAE,GAAS,EAAA;AACjE,IAAA,OAAO,IAAI,cAAc,CAAC,IAAI,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,wBAAwB,EAAE;AACzF;;;;"}

package/account/index.d.ts

@@ -1,5 +0,0 @@
-export * from './account';
-export * from './get-account';
-export * from './get-account-config-from-environment';
-export * from './get-dispenser-account';
-export * from './mnemonic-account';

package/account/mnemonic-account.d.ts

@@ -1,13 +0,0 @@
-import algosdk from 'algosdk';
-import Account = algosdk.Account;
-/**
- * @deprecated Use `algorand.account.fromMnemonic(mnemonicSecret)` or `algosdk.mnemonicToSecretKey(mnemonicSecret)` instead.
- *
- * Returns an Algorand account with secret key loaded (i.e. that can sign transactions) by taking the mnemonic secret.
- *
- * This is a wrapper around algosdk.mnemonicToSecretKey to provide a more friendly/obvious name.
- *
- * @param mnemonicSecret The mnemonic secret representing the private key of an account; **Note: Be careful how the mnemonic is handled**,
- *  never commit it into source control and ideally load it from the environment (ideally via a secret storage service) rather than the file system.
- */
-export declare function mnemonicAccount(mnemonicSecret: string): Account;

package/account/mnemonic-account.js

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

package/account/mnemonic-account.js.map

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

package/account/mnemonic-account.mjs

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

package/account/mnemonic-account.mjs.map

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

package/app-client.d.ts

@@ -1,86 +0,0 @@
-import algosdk from 'algosdk';
-import { AppSpecAppDetails, AppSpecAppDetailsByCreatorAndName, AppSpecAppDetailsById, ApplicationClient } from './types/app-client';
-import Algodv2 = algosdk.Algodv2;
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById` or
- * `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- * Create a new ApplicationClient instance
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example Resolve by creator and name
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'creatorAndName',
- *       app: {appSpec},
- *       sender: {account},
- *       creatorAddress: {creator},
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @example Resolve by id:
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'id',
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *    algodClient,
- * )
- *
- * @returns The application client
- */
-export declare function getAppClient(appDetails: AppSpecAppDetails, algod: Algodv2): ApplicationClient;
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by id
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientById(
- *     {
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-export declare function getAppClientById(appDetails: AppSpecAppDetailsById, algod: Algodv2): ApplicationClient;
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by creator and name
- * @param appDetails The details of the app by creator and name
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientByCreatorAndName(
- *     {
- *       app: appSpec,
- *       sender: account,
- *       creatorAddress: account,
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-export declare function getAppClientByCreatorAndName(appDetails: AppSpecAppDetailsByCreatorAndName, algod: Algodv2): ApplicationClient;

package/app-client.js

@@ -1,98 +0,0 @@
-'use strict';
-
-var types_appClient = require('./types/app-client.js');
-
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById` or
- * `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- * Create a new ApplicationClient instance
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example Resolve by creator and name
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'creatorAndName',
- *       app: {appSpec},
- *       sender: {account},
- *       creatorAddress: {creator},
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @example Resolve by id:
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'id',
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *    algodClient,
- * )
- *
- * @returns The application client
- */
-function getAppClient(appDetails, algod) {
-    return new types_appClient.ApplicationClient(appDetails, algod);
-}
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by id
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientById(
- *     {
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-function getAppClientById(appDetails, algod) {
-    return new types_appClient.ApplicationClient({ ...appDetails, resolveBy: 'id' }, algod);
-}
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by creator and name
- * @param appDetails The details of the app by creator and name
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientByCreatorAndName(
- *     {
- *       app: appSpec,
- *       sender: account,
- *       creatorAddress: account,
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-function getAppClientByCreatorAndName(appDetails, algod) {
-    return new types_appClient.ApplicationClient({ ...appDetails, resolveBy: 'creatorAndName' }, algod);
-}
-
-exports.getAppClient = getAppClient;
-exports.getAppClientByCreatorAndName = getAppClientByCreatorAndName;
-exports.getAppClientById = getAppClientById;
-//# sourceMappingURL=app-client.js.map

package/app-client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-client.js","sources":["../src/app-client.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AppSpecAppDetails, AppSpecAppDetailsByCreatorAndName, AppSpecAppDetailsById, ApplicationClient } from './types/app-client'\nimport Algodv2 = algosdk.Algodv2\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById` or\n * `algorand.client.getAppClientByCreatorAndName`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n * Create a new ApplicationClient instance\n * @param appDetails The details of the app\n * @param algod An algod instance\n *\n * @example Resolve by creator and name\n * const client = algokit.getAppClient(\n *     {\n *       resolveBy: 'creatorAndName',\n *       app: {appSpec},\n *       sender: {account},\n *       creatorAddress: {creator},\n *       findExistingUsing: indexerClient,\n *     },\n *     algodClient,\n *   )\n *\n * @example Resolve by id:\n * const client = algokit.getAppClient(\n *     {\n *       resolveBy: 'id',\n *       app: {appSpec},\n *       sender: {account},\n *       id: {id},\n *     },\n *    algodClient,\n * )\n *\n * @returns The application client\n */\nexport function getAppClient(appDetails: AppSpecAppDetails, algod: Algodv2) {\n  return new ApplicationClient(appDetails, algod)\n}\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n *\n * Create a new ApplicationClient instance by id\n * @param appDetails The details of the app\n * @param algod An algod instance\n *\n * @example\n * const client = algokit.getAppClientById(\n *     {\n *       app: {appSpec},\n *       sender: {account},\n *       id: {id},\n *     },\n *     algodClient,\n *   )\n *\n * @returns The application client\n */\nexport function getAppClientById(appDetails: AppSpecAppDetailsById, algod: Algodv2) {\n  return new ApplicationClient({ ...appDetails, resolveBy: 'id' }, algod)\n}\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientByCreatorAndName`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n *\n * Create a new ApplicationClient instance by creator and name\n * @param appDetails The details of the app by creator and name\n * @param algod An algod instance\n *\n * @example\n * const client = algokit.getAppClientByCreatorAndName(\n *     {\n *       app: appSpec,\n *       sender: account,\n *       creatorAddress: account,\n *       findExistingUsing: indexerClient,\n *     },\n *     algodClient,\n *   )\n *\n * @returns The application client\n */\nexport function getAppClientByCreatorAndName(appDetails: AppSpecAppDetailsByCreatorAndName, algod: Algodv2) {\n  return new ApplicationClient({ ...appDetails, resolveBy: 'creatorAndName' }, algod)\n}\n"],"names":["ApplicationClient"],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACa,SAAA,YAAY,CAAC,UAA6B,EAAE,KAAc,EAAA;AACxE,IAAA,OAAO,IAAIA,iCAAiB,CAAC,UAAU,EAAE,KAAK,CAAC;AACjD;AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACa,SAAA,gBAAgB,CAAC,UAAiC,EAAE,KAAc,EAAA;AAChF,IAAA,OAAO,IAAIA,iCAAiB,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,KAAK,CAAC;AACzE;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACa,SAAA,4BAA4B,CAAC,UAA6C,EAAE,KAAc,EAAA;AACxG,IAAA,OAAO,IAAIA,iCAAiB,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,EAAE,KAAK,CAAC;AACrF;;;;;;"}

package/app-client.mjs

@@ -1,94 +0,0 @@
-import { ApplicationClient } from './types/app-client.mjs';
-
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById` or
- * `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- * Create a new ApplicationClient instance
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example Resolve by creator and name
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'creatorAndName',
- *       app: {appSpec},
- *       sender: {account},
- *       creatorAddress: {creator},
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @example Resolve by id:
- * const client = algokit.getAppClient(
- *     {
- *       resolveBy: 'id',
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *    algodClient,
- * )
- *
- * @returns The application client
- */
-function getAppClient(appDetails, algod) {
-    return new ApplicationClient(appDetails, algod);
-}
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by id
- * @param appDetails The details of the app
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientById(
- *     {
- *       app: {appSpec},
- *       sender: {account},
- *       id: {id},
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-function getAppClientById(appDetails, algod) {
-    return new ApplicationClient({ ...appDetails, resolveBy: 'id' }, algod);
-}
-/**
- * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientByCreatorAndName`.
- * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,
- * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.
- *
- *
- * Create a new ApplicationClient instance by creator and name
- * @param appDetails The details of the app by creator and name
- * @param algod An algod instance
- *
- * @example
- * const client = algokit.getAppClientByCreatorAndName(
- *     {
- *       app: appSpec,
- *       sender: account,
- *       creatorAddress: account,
- *       findExistingUsing: indexerClient,
- *     },
- *     algodClient,
- *   )
- *
- * @returns The application client
- */
-function getAppClientByCreatorAndName(appDetails, algod) {
-    return new ApplicationClient({ ...appDetails, resolveBy: 'creatorAndName' }, algod);
-}
-
-export { getAppClient, getAppClientByCreatorAndName, getAppClientById };
-//# sourceMappingURL=app-client.mjs.map

package/app-client.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-client.mjs","sources":["../src/app-client.ts"],"sourcesContent":["import algosdk from 'algosdk'\nimport { AppSpecAppDetails, AppSpecAppDetailsByCreatorAndName, AppSpecAppDetailsById, ApplicationClient } from './types/app-client'\nimport Algodv2 = algosdk.Algodv2\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById` or\n * `algorand.client.getAppClientByCreatorAndName`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n * Create a new ApplicationClient instance\n * @param appDetails The details of the app\n * @param algod An algod instance\n *\n * @example Resolve by creator and name\n * const client = algokit.getAppClient(\n *     {\n *       resolveBy: 'creatorAndName',\n *       app: {appSpec},\n *       sender: {account},\n *       creatorAddress: {creator},\n *       findExistingUsing: indexerClient,\n *     },\n *     algodClient,\n *   )\n *\n * @example Resolve by id:\n * const client = algokit.getAppClient(\n *     {\n *       resolveBy: 'id',\n *       app: {appSpec},\n *       sender: {account},\n *       id: {id},\n *     },\n *    algodClient,\n * )\n *\n * @returns The application client\n */\nexport function getAppClient(appDetails: AppSpecAppDetails, algod: Algodv2) {\n  return new ApplicationClient(appDetails, algod)\n}\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientById`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n *\n * Create a new ApplicationClient instance by id\n * @param appDetails The details of the app\n * @param algod An algod instance\n *\n * @example\n * const client = algokit.getAppClientById(\n *     {\n *       app: {appSpec},\n *       sender: {account},\n *       id: {id},\n *     },\n *     algodClient,\n *   )\n *\n * @returns The application client\n */\nexport function getAppClientById(appDetails: AppSpecAppDetailsById, algod: Algodv2) {\n  return new ApplicationClient({ ...appDetails, resolveBy: 'id' }, algod)\n}\n\n/**\n * @deprecated Use `AppClient` instead e.g. via `algorand.client.getAppClientByCreatorAndName`.\n * If you want to `create` or `deploy` then use `AppFactory` e.g. via `algorand.client.getAppFactory`,\n * which will in turn give you an `AppClient` instance against the created/deployed app to make other calls.\n *\n *\n * Create a new ApplicationClient instance by creator and name\n * @param appDetails The details of the app by creator and name\n * @param algod An algod instance\n *\n * @example\n * const client = algokit.getAppClientByCreatorAndName(\n *     {\n *       app: appSpec,\n *       sender: account,\n *       creatorAddress: account,\n *       findExistingUsing: indexerClient,\n *     },\n *     algodClient,\n *   )\n *\n * @returns The application client\n */\nexport function getAppClientByCreatorAndName(appDetails: AppSpecAppDetailsByCreatorAndName, algod: Algodv2) {\n  return new ApplicationClient({ ...appDetails, resolveBy: 'creatorAndName' }, algod)\n}\n"],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACa,SAAA,YAAY,CAAC,UAA6B,EAAE,KAAc,EAAA;AACxE,IAAA,OAAO,IAAI,iBAAiB,CAAC,UAAU,EAAE,KAAK,CAAC;AACjD;AAEA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACa,SAAA,gBAAgB,CAAC,UAAiC,EAAE,KAAc,EAAA;AAChF,IAAA,OAAO,IAAI,iBAAiB,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,KAAK,CAAC;AACzE;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACa,SAAA,4BAA4B,CAAC,UAA6C,EAAE,KAAc,EAAA;AACxG,IAAA,OAAO,IAAI,iBAAiB,CAAC,EAAE,GAAG,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,EAAE,KAAK,CAAC;AACrF;;;;"}