@algorandfoundation/algokit-utils 1.0.0-beta.8 → 1.0.0-beta.9

package/localnet.d.ts

@@ -0,0 +1,54 @@
+import { Account, Algodv2, Kmd } from 'algosdk';
+import { AlgoAmount } from './algo-amount';
+/** Returns true if the algod client is pointing to a LocalNet Algorand network */
+export declare function isLocalNet(algod: Algodv2): Promise<boolean>;
+/**
+ * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+ *
+ * This is useful to get idempotent accounts from a local sandbox without having to specify the private key (which will change when resetting the sandbox).
+ *
+ * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh sandbox.
+ *
+ * If this is used via @see {getAccount}, then you can even use the same code that runs on production without changes for local development!
+ *
+ * @param walletAccount The wallet details with:
+ *   * `name`: The name of the wallet to retrieve / create
+ *   * `fundWith`: The number of Algos to fund the account with it it gets created, if not specified then 1000 Algos will be funded from the dispenser account @see {getDispenserAccount}
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ *
+ * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
+ */
+export declare function getOrCreateKmdWalletAccount(walletAccount: {
+    name: string;
+    fundWith?: AlgoAmount;
+}, algod: Algodv2, kmdClient?: Kmd): Promise<Account>;
+/**
+ * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+ *
+ * @param walletAccount The details of the wallet, with:
+ *   * `name`: The name of the wallet to retrieve an account from
+ *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ * @example Get default funded account in a LocalNet
+ *
+ * ```
+ * const defaultDispenserAccount = await getKmdWalletAccount(algod,
+ *   'unencrypted-default-wallet',
+ *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+ * )
+ * ```
+ */
+export declare function getKmdWalletAccount(walletAccount: {
+    name: string;
+    predicate?: (account: Record<string, any>) => boolean;
+}, algod: Algodv2, kmdClient?: Kmd): Promise<Account | undefined>;
+/**
+ * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
+ *
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ */
+export declare function getLocalNetDispenserAccount(algod: Algodv2, kmdClient?: Kmd): Promise<Account>;
+//# sourceMappingURL=localnet.d.ts.map

package/localnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localnet.d.ts","sourceRoot":"","sources":["../src/localnet.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAExD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAK1C,kFAAkF;AAClF,wBAAsB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAIjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,2BAA2B,CAC/C,aAAa,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,EACtD,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,CAAC,CAmClB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,aAAa,EAAE;IACb,IAAI,EAAE,MAAM,CAAA;IAEZ,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAA;CACtD,EACD,KAAK,EAAE,OAAO,EACd,SAAS,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAmC9B;AAED;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAWnG"}

package/localnet.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalNetDispenserAccount = exports.getKmdWalletAccount = exports.getOrCreateKmdWalletAccount = exports.isLocalNet = void 0;
+const algosdk_1 = __importDefault(require("algosdk"));
+const account_1 = require("./account");
+const algo_amount_1 = require("./algo-amount");
+const config_1 = require("./config");
+const network_client_1 = require("./network-client");
+const transfer_1 = require("./transfer");
+/** Returns true if the algod client is pointing to a LocalNet Algorand network */
+async function isLocalNet(algod) {
+    const params = await algod.getTransactionParams().do();
+    return params.genesisID === 'devnet-v1' || params.genesisID === 'sandnet-v1';
+}
+exports.isLocalNet = isLocalNet;
+/**
+ * Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+ *
+ * This is useful to get idempotent accounts from a local sandbox without having to specify the private key (which will change when resetting the sandbox).
+ *
+ * This significantly speeds up local dev time and improves experience since you can write code that *just works* first go without manual config in a fresh sandbox.
+ *
+ * If this is used via @see {getAccount}, then you can even use the same code that runs on production without changes for local development!
+ *
+ * @param walletAccount The wallet details with:
+ *   * `name`: The name of the wallet to retrieve / create
+ *   * `fundWith`: The number of Algos to fund the account with it it gets created, if not specified then 1000 Algos will be funded from the dispenser account @see {getDispenserAccount}
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ *
+ * @returns An Algorand account with private key loaded - either one that already existed in the given KMD wallet, or a new one that is funded for you
+ */
+async function getOrCreateKmdWalletAccount(walletAccount, algod, kmdClient) {
+    const kmd = kmdClient ?? (0, network_client_1.getAlgoKmdClient)();
+    // Get an existing account from the KMD wallet
+    const existing = await getKmdWalletAccount(walletAccount, algod, kmd);
+    if (existing) {
+        return existing;
+    }
+    // None existed: create the KMD wallet instead
+    const walletId = (await kmd.createWallet(walletAccount.name, '')).wallet.id;
+    const walletHandle = (await kmd.initWalletHandle(walletId, '')).wallet_handle_token;
+    await kmd.generateKey(walletHandle);
+    // Get the account from the new KMD wallet
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const account = (await getKmdWalletAccount(walletAccount, algod, kmd));
+    config_1.AlgoKitConfig.logger.info(`Couldn't find existing account in Sandbox under name '${walletAccount.name}'; created account ${account.addr} with keys stored in KMD and funding with ${walletAccount.fundWith?.algos ?? 1000} ALGOs`);
+    // Fund the account from the dispenser
+    await (0, transfer_1.transferAlgos)({
+        amount: walletAccount.fundWith ?? algo_amount_1.AlgoAmount.Algos(1000),
+        from: await (0, account_1.getDispenserAccount)(algod),
+        to: account.addr,
+    }, algod);
+    return account;
+}
+exports.getOrCreateKmdWalletAccount = getOrCreateKmdWalletAccount;
+/**
+ * Returns an Algorand account with private key loaded from the given KMD wallet (identified by name).
+ *
+ * @param walletAccount The details of the wallet, with:
+ *   * `name`: The name of the wallet to retrieve an account from
+ *   * `predicate`: An optional filter to use to find the account (otherwise it will return a random account from the wallet)
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ * @example Get default funded account in a LocalNet
+ *
+ * ```
+ * const defaultDispenserAccount = await getKmdWalletAccount(algod,
+ *   'unencrypted-default-wallet',
+ *   a => a.status !== 'Offline' && a.amount > 1_000_000_000
+ * )
+ * ```
+ */
+async function getKmdWalletAccount(walletAccount, algod, kmdClient) {
+    const { name, predicate } = walletAccount;
+    const kmd = kmdClient ?? (0, network_client_1.getAlgoKmdClient)();
+    const wallets = await kmd.listWallets();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const wallet = wallets.wallets.filter((w) => w.name === name);
+    if (wallet.length === 0) {
+        return undefined;
+    }
+    const walletId = wallet[0].id;
+    const walletHandle = (await kmd.initWalletHandle(walletId, '')).wallet_handle_token;
+    const keyIds = (await kmd.listKeys(walletHandle)).addresses;
+    let i = 0;
+    if (predicate) {
+        for (i = 0; i < keyIds.length; i++) {
+            const key = keyIds[i];
+            const account = await algod.accountInformation(key).do();
+            if (predicate(account)) {
+                break;
+            }
+        }
+    }
+    if (i >= keyIds.length) {
+        return undefined;
+    }
+    const accountKey = (await kmd.exportKey(walletHandle, '', keyIds[i])).private_key;
+    const accountMnemonic = algosdk_1.default.secretKeyToMnemonic(accountKey);
+    return (0, account_1.getAccountFromMnemonic)(accountMnemonic);
+}
+exports.getKmdWalletAccount = getKmdWalletAccount;
+/**
+ * Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
+ *
+ * @param algod An algod client
+ * @param kmdClient A KMD client, if not specified then a default KMD client will be loaded from environment variables @see {getAlgoKmdClient}
+ */
+async function getLocalNetDispenserAccount(algod, kmdClient) {
+    if (!(await isLocalNet(algod))) {
+        throw "Can't get default account from non LocalNet network";
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return (await getKmdWalletAccount({ name: 'unencrypted-default-wallet', predicate: (a) => a.status !== 'Offline' && a.amount > 1000000000 }, algod, kmdClient));
+}
+exports.getLocalNetDispenserAccount = getLocalNetDispenserAccount;
+//# sourceMappingURL=localnet.js.map

package/localnet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localnet.js","sourceRoot":"","sources":["../src/localnet.ts"],"names":[],"mappings":"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"}

package/network-client.d.ts

@@ -0,0 +1,102 @@
+import { Algodv2, Indexer, Kmd } from 'algosdk';
+import { TokenHeader } from 'algosdk/dist/types/client/urlTokenBaseHTTPClient';
+/** Config for an Algorand SDK client */
+export interface AlgoClientConfig {
+    /** Base URL of the server e.g. http://localhost, https://testnet-api.algonode.cloud/, etc. */
+    server: string;
+    /** The port to use e.g. 4001, 443, etc. */
+    port?: string | number;
+    /** The token to use for API authentication (or undefined if none needed) - can be a string, or an object with the header key => value */
+    token?: string | TokenHeader;
+}
+/** Retrieve the algod configuration from environment variables (expects to be called from a Node.js environment not algod-side) */
+export declare function getAlgodConfigFromEnvironment(): AlgoClientConfig;
+/** Retrieve the indexer configuration from environment variables (expects to be called from a Node.js environment not algod-side) */
+export declare function getIndexerConfigFromEnvironment(): AlgoClientConfig;
+/** Returns the Algorand configuration to point to the AlgoNode service
+ *
+ * @param network Which network to connect to - TestNet or MainNet
+ * @param config Which algod config to return - Algod or Indexer
+ */
+export declare function getAlgoNodeConfig(network: 'testnet' | 'mainnet', config: 'algod' | 'indexer'): AlgoClientConfig;
+/** Returns the Algorand configuration to point to the default LocalNet
+ *
+ * @param configOrPort Which algod config to return - algod, kmd, or indexer OR a port number
+ */
+export declare function getDefaultLocalNetConfig(configOrPort: 'algod' | 'indexer' | 'kmd' | number): AlgoClientConfig;
+/** Returns an algod SDK client that automatically retries on idempotent calls
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.ALGOD_SERVER, process.env.ALGOD_PORT and process.env.ALGOD_TOKEN
+ *  // Automatically detects if you are using PureStake to switch in the right header name for ALGOD_TOKEN
+ *  const algod = getAlgoClient()
+ *  await algod.healthCheck().do()
+ *  ```
+ * @example AlgoNode (testnet)
+ * ```
+ *  const algod = getAlgoClient(getAlgoNodeConfig('testnet', 'algod'))
+ *  await algod.healthCheck().do()
+ * ```
+ * @example AlgoNode (mainnet)
+ * ```
+ *  const algod = getAlgoClient(getAlgoNodeConfig('mainnet', 'algod'))
+ *  await algod.healthCheck().do()
+ * ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const algod = getAlgoClient({server: 'http://localhost', port: '4001', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ *  await algod.healthCheck().do()
+ * ```
+ */
+export declare function getAlgoClient(config?: AlgoClientConfig): Algodv2;
+/** Returns an indexer SDK client that automatically retries on idempotent calls
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.INDEXER_SERVER, process.env.INDEXER_PORT and process.env.INDEXER_TOKEN
+ *  // Automatically detects if you are using PureStake to switch in the right header name for INDEXER_TOKEN
+ *  const indexer = getAlgoIndexerClient()
+ *  await indexer.makeHealthCheck().do()
+ *  ```
+ * @example AlgoNode (testnet)
+ * ```
+ *  const indexer = getAlgoIndexerClient(getAlgoNodeConfig('testnet', 'indexer'))
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ * @example AlgoNode (mainnet)
+ * ```
+ *  const indexer = getAlgoIndexerClient(getAlgoNodeConfig('mainnet', 'indexer'))
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const indexer = getAlgoIndexerClient({server: 'http://localhost', port: '8980', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ */
+export declare function getAlgoIndexerClient(config?: AlgoClientConfig): Indexer;
+/**
+ * Returns a KMD SDK client that automatically retries on idempotent calls
+ *
+ * KMD client allows you to export private keys, which is useful to get the default account in a sandbox network.
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.ALGOD_SERVER, process.env.KMD_PORT (or if not specified: port 4002) and process.env.ALGOD_TOKEN
+ *  const kmd = getAlgoKmdClient()
+ *  ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const kmd = getAlgoKmdClient({server: 'http://localhost', port: '4002', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ * ```
+ */
+export declare function getAlgoKmdClient(config?: AlgoClientConfig): Kmd;
+export { isLocalNet } from './localnet';
+//# sourceMappingURL=network-client.d.ts.map

package/network-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-client.d.ts","sourceRoot":"","sources":["../src/network-client.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,kDAAkD,CAAA;AAG9E,wCAAwC;AACxC,MAAM,WAAW,gBAAgB;IAC/B,8FAA8F;IAC9F,MAAM,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,yIAAyI;IACzI,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;CAC7B;AAED,mIAAmI;AACnI,wBAAgB,6BAA6B,IAAI,gBAAgB,CAchE;AAED,qIAAqI;AACrI,wBAAgB,+BAA+B,IAAI,gBAAgB,CAclE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,gBAAgB,CAK/G;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,gBAAgB,CAM7G;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAIhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAIvE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,GAAG,CAK/D;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA"}

package/network-client.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalNet = exports.getAlgoKmdClient = exports.getAlgoIndexerClient = exports.getAlgoClient = exports.getDefaultLocalNetConfig = exports.getAlgoNodeConfig = exports.getIndexerConfigFromEnvironment = exports.getAlgodConfigFromEnvironment = void 0;
+const algosdk_1 = __importStar(require("algosdk"));
+const algo_http_client_with_retry_1 = require("./algo-http-client-with-retry");
+/** Retrieve the algod configuration from environment variables (expects to be called from a Node.js environment not algod-side) */
+function getAlgodConfigFromEnvironment() {
+    if (!process || !process.env) {
+        throw new Error('Attempt to get default algod configuration from a non Node.js context; supply the config instead');
+    }
+    if (!process.env.ALGOD_SERVER) {
+        throw new Error('Attempt to get default algod configuration without specifying ALGOD_SERVER in the environment variables');
+    }
+    return {
+        server: process.env.ALGOD_SERVER,
+        port: process.env.ALGOD_PORT,
+        token: process.env.ALGOD_TOKEN,
+    };
+}
+exports.getAlgodConfigFromEnvironment = getAlgodConfigFromEnvironment;
+/** Retrieve the indexer configuration from environment variables (expects to be called from a Node.js environment not algod-side) */
+function getIndexerConfigFromEnvironment() {
+    if (!process || !process.env) {
+        throw new Error('Attempt to get default indexer configuration from a non Node.js context; supply the config instead');
+    }
+    if (!process.env.INDEXER_SERVER) {
+        throw new Error('Attempt to get default indexer configuration without specifying INDEXER_SERVER in the environment variables');
+    }
+    return {
+        server: process.env.INDEXER_SERVER,
+        port: process.env.INDEXER_PORT,
+        token: process.env.INDEXER_TOKEN,
+    };
+}
+exports.getIndexerConfigFromEnvironment = getIndexerConfigFromEnvironment;
+/** Returns the Algorand configuration to point to the AlgoNode service
+ *
+ * @param network Which network to connect to - TestNet or MainNet
+ * @param config Which algod config to return - Algod or Indexer
+ */
+function getAlgoNodeConfig(network, config) {
+    return {
+        server: `https://${network}-${config === 'algod' ? 'api' : 'idx'}.algonode.cloud/`,
+        port: 443,
+    };
+}
+exports.getAlgoNodeConfig = getAlgoNodeConfig;
+/** Returns the Algorand configuration to point to the default LocalNet
+ *
+ * @param configOrPort Which algod config to return - algod, kmd, or indexer OR a port number
+ */
+function getDefaultLocalNetConfig(configOrPort) {
+    return {
+        server: `http://localhost`,
+        port: configOrPort === 'algod' ? 4001 : configOrPort === 'indexer' ? 8980 : configOrPort === 'kmd' ? 4002 : configOrPort,
+        token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    };
+}
+exports.getDefaultLocalNetConfig = getDefaultLocalNetConfig;
+function getAlgoTokenHeader(server, token, defaultHeader) {
+    // Purestake uses a slightly different API key header than the default
+    if (server.includes('purestake.io') && typeof token === 'string')
+        return { 'X-API-Key': token };
+    // Because we override the default HTTP Client construction (to get retries) we need to put a string token into the standard header ourselves
+    return typeof token === 'string' ? { [defaultHeader ?? 'X-Algo-API-Token']: token } : token ?? {};
+}
+/** Returns an algod SDK client that automatically retries on idempotent calls
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.ALGOD_SERVER, process.env.ALGOD_PORT and process.env.ALGOD_TOKEN
+ *  // Automatically detects if you are using PureStake to switch in the right header name for ALGOD_TOKEN
+ *  const algod = getAlgoClient()
+ *  await algod.healthCheck().do()
+ *  ```
+ * @example AlgoNode (testnet)
+ * ```
+ *  const algod = getAlgoClient(getAlgoNodeConfig('testnet', 'algod'))
+ *  await algod.healthCheck().do()
+ * ```
+ * @example AlgoNode (mainnet)
+ * ```
+ *  const algod = getAlgoClient(getAlgoNodeConfig('mainnet', 'algod'))
+ *  await algod.healthCheck().do()
+ * ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const algod = getAlgoClient({server: 'http://localhost', port: '4001', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ *  await algod.healthCheck().do()
+ * ```
+ */
+function getAlgoClient(config) {
+    const { token, server, port } = config ?? getAlgodConfigFromEnvironment();
+    const httpClientWithRetry = new algo_http_client_with_retry_1.AlgoHttpClientWithRetry(getAlgoTokenHeader(server, token), server, port);
+    return new algosdk_1.default.Algodv2(httpClientWithRetry, server);
+}
+exports.getAlgoClient = getAlgoClient;
+/** Returns an indexer SDK client that automatically retries on idempotent calls
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.INDEXER_SERVER, process.env.INDEXER_PORT and process.env.INDEXER_TOKEN
+ *  // Automatically detects if you are using PureStake to switch in the right header name for INDEXER_TOKEN
+ *  const indexer = getAlgoIndexerClient()
+ *  await indexer.makeHealthCheck().do()
+ *  ```
+ * @example AlgoNode (testnet)
+ * ```
+ *  const indexer = getAlgoIndexerClient(getAlgoNodeConfig('testnet', 'indexer'))
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ * @example AlgoNode (mainnet)
+ * ```
+ *  const indexer = getAlgoIndexerClient(getAlgoNodeConfig('mainnet', 'indexer'))
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const indexer = getAlgoIndexerClient({server: 'http://localhost', port: '8980', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ *  await indexer.makeHealthCheck().do()
+ * ```
+ */
+function getAlgoIndexerClient(config) {
+    const { token, server, port } = config ?? getIndexerConfigFromEnvironment();
+    const httpClientWithRetry = new algo_http_client_with_retry_1.AlgoHttpClientWithRetry(getAlgoTokenHeader(server, token, 'X-Indexer-API-Token'), server, port);
+    return new algosdk_1.Indexer(httpClientWithRetry);
+}
+exports.getAlgoIndexerClient = getAlgoIndexerClient;
+/**
+ * Returns a KMD SDK client that automatically retries on idempotent calls
+ *
+ * KMD client allows you to export private keys, which is useful to get the default account in a sandbox network.
+ *
+ * @param config The config if you want to override the default (getting config from process.env)
+ * @example Default (load from environment variables)
+ *
+ *  ```
+ *  // Uses process.env.ALGOD_SERVER, process.env.KMD_PORT (or if not specified: port 4002) and process.env.ALGOD_TOKEN
+ *  const kmd = getAlgoKmdClient()
+ *  ```
+ * @example Custom (e.g. default local sandbox, although we recommend loading this into a .env and using the Default option instead)
+ * ```
+ *  const kmd = getAlgoKmdClient({server: 'http://localhost', port: '4002', token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})
+ * ```
+ */
+function getAlgoKmdClient(config) {
+    const { token, server } = config ?? getAlgodConfigFromEnvironment();
+    // We can only use Kmd on the Sandbox otherwise it's not exposed so this makes some assumptions
+    // (e.g. same token and server as algod and port 4002 by default)
+    return new algosdk_1.Kmd(token, server, process?.env?.KMD_PORT ?? '4002');
+}
+exports.getAlgoKmdClient = getAlgoKmdClient;
+var localnet_1 = require("./localnet");
+Object.defineProperty(exports, "isLocalNet", { enumerable: true, get: function () { return localnet_1.isLocalNet; } });
+//# sourceMappingURL=network-client.js.map

package/network-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-client.js","sourceRoot":"","sources":["../src/network-client.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "name": "@algorandfoundation/algokit-utils",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-beta.9",
   "private": false,
   "description": "A set of core Algorand utilities written in TypeScript and released via npm that make it easier to build solutions on Algorand.",
   "author": "Algorand Foundation",
@@ -11,7 +11,7 @@
     "node": ">=16.0"
   },
   "files": [
-    "dist/**/*"
+    "**/*"
   ],
   "dependencies": {
     "algosdk": "^2.1.0",

package/transaction.d.ts

@@ -0,0 +1,157 @@
+import algosdk, { Account, Algodv2, LogicSigAccount, MultisigMetadata, SuggestedParams, Transaction, TransactionSigner } from 'algosdk';
+import { AlgoAmount } from './algo-amount';
+import { PendingTransactionResponse } from './types/algod';
+/** Account wrapper that supports partial or full multisig signing */
+export declare class MultisigAccount {
+    _params: algosdk.MultisigMetadata;
+    _signingAccounts: (algosdk.Account | SigningAccount)[];
+    _addr: string;
+    get params(): Readonly<algosdk.MultisigMetadata>;
+    get signingAccounts(): Readonly<(algosdk.Account | SigningAccount)[]>;
+    get addr(): Readonly<string>;
+    constructor(multisigParams: MultisigMetadata, signingAccounts: (Account | SigningAccount)[]);
+    sign(transaction: Transaction | Uint8Array): Uint8Array;
+}
+/** Account wrapper that supports a rekeyed account */
+export declare class SigningAccount implements Account {
+    private _account;
+    private _sender;
+    /**
+     * Algorand address of the sender
+     */
+    get addr(): Readonly<string>;
+    /**
+     * Secret key belonging to the signer
+     */
+    get sk(): Readonly<Uint8Array>;
+    /**
+     * Algorand account of the underlying signing account
+     */
+    get signer(): Account;
+    /**
+     * Algorand account of the sender address and signer private key
+     */
+    get sender(): Account;
+    constructor(account: Account, sender: string | undefined);
+}
+/** A wrapper around @see {TransactionSigner} that also has the sender address. */
+export interface TransactionSignerAccount {
+    addr: Readonly<string>;
+    signer: TransactionSigner;
+}
+export type TransactionNote = Uint8Array | TransactionNoteData | Arc2TransactionNote;
+export type TransactionNoteData = string | null | undefined | number | any[] | Record<string, any>;
+/** ARC-0002 compatible transaction note components, @see https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md */
+export type Arc2TransactionNote = {
+    dAppName: string;
+    format: 'm' | 'j' | 'b' | 'u';
+    data: string;
+};
+/** Encodes a transaction note into a byte array ready to be included in an Algorand transaction.
+ *
+ * @param note The transaction note
+ * @returns the transaction note ready for inclusion in a transaction
+ *
+ *  Case on the value of `data` this either either be:
+ *   * `null` | `undefined`: `undefined`
+ *   * `string`: The string value
+ *   * Uint8Array: passthrough
+ *   * Arc2TransactionNote object: ARC-0002 compatible transaction note
+ *   * Else: The object/value converted into a JSON string representation
+ */
+export declare function encodeTransactionNote(note?: TransactionNote): Uint8Array | undefined;
+/** The sending configuration for a transaction */
+export interface SendTransactionParams {
+    /** Whether to skip signing and sending the transaction to the chain (default: transaction signed and sent to chain)
+     *   (and instead just return the raw transaction, e.g. so you can add it to a group of transactions) */
+    skipSending?: boolean;
+    /** Whether to skip waiting for the submitted transaction (only relevant if `skipSending` is `false` or unset) */
+    skipWaiting?: boolean;
+    /** Whether to suppress log messages from transaction send, default: do not suppress */
+    suppressLog?: boolean;
+    /** The maximum fee that you are happy to pay (default: unbounded) - if this is set it's possible the transaction could get rejected during network congestion */
+    maxFee?: AlgoAmount;
+    /** The maximum number of rounds to wait for confirmation, only applies if `skipWaiting` is `undefined` or `false`, default: wait up to 5 rounds */
+    maxRoundsToWaitForConfirmation?: number;
+}
+/** The result of sending a transaction */
+export interface SendTransactionResult {
+    /** The transaction */
+    transaction: Transaction;
+    /** The response if the transaction was sent and waited for */
+    confirmation?: PendingTransactionResponse;
+}
+export type SendTransactionFrom = Account | SigningAccount | LogicSigAccount | MultisigAccount | TransactionSignerAccount;
+/**
+ * Returns the public address of the given transaction sender.
+ * @param sender A transaction sender
+ * @returns The public address
+ */
+export declare const getSenderAddress: (sender: SendTransactionFrom) => string;
+/** Signs and sends the given transaction to the chain
+ *
+ * @param send The details for the transaction to send, including:
+ *   * `transaction`: The unsigned transaction
+ *   * `from`: The account to sign the transaction with: either an account with private key loaded or a logic signature account
+ *   * `config`: The sending configuration for this transaction
+ * @param algod An algod client
+ *
+ * @returns An object with transaction (`transaction`) and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)
+ */
+export declare const sendTransaction: (send: {
+    transaction: Transaction;
+    from: SendTransactionFrom;
+    sendParams?: SendTransactionParams;
+}, algod: Algodv2) => Promise<SendTransactionResult>;
+/** Defines an unsigned transaction that will appear in a group of transactions along with its signing information */
+export interface TransactionToSign {
+    /** The unsigned transaction to sign and send */
+    transaction: Transaction;
+    /** The account to use to sign the transaction, either an account (with private key loaded) or a logic signature account */
+    signer: SendTransactionFrom;
+}
+/**
+ * Signs and sends a group of [up to 16](https://developer.algorand.org/docs/get-details/atomic_transfers/#create-transactions) transactions to the chain
+ *
+ * @param groupSend The group details to send, with:
+ *   * `transactions`: The array of transactions to send along with their signing account
+ *   * `sendParams`: The parameters to dictate how the group is sent
+ * @param algod An algod client
+ * @returns An object with group transaction ID (`groupTransactionId`) and (if `skipWaiting` is `false` or unset) confirmation (`confirmation`)
+ */
+export declare const sendGroupOfTransactions: (groupSend: {
+    transactions: TransactionToSign[];
+    sendParams?: Omit<Omit<SendTransactionParams, 'maxFee'>, 'skipSending'>;
+}, algod: Algodv2) => Promise<{
+    groupId: string;
+    confirmations: PendingTransactionResponse[] | undefined;
+    txIds: string[];
+}>;
+/**
+ * Wait until the transaction is confirmed or rejected, or until `timeout`
+ * number of rounds have passed.
+ *
+ * @param algod An algod client
+ * @param transactionId The transaction ID to wait for
+ * @param maxRoundsToWait Maximum number of rounds to wait
+ *
+ * @return Pending transaction information
+ * @throws Throws an error if the transaction is not confirmed or rejected in the next `timeout` rounds
+ */
+export declare const waitForConfirmation: (transactionId: string, maxRoundsToWait: number, algod: Algodv2) => Promise<PendingTransactionResponse>;
+/**
+ * Limit the acceptable fee to a defined amount of µALGOs.
+ * This also sets the transaction to be flatFee to ensure the transaction only succeeds at
+ * the estimated rate.
+ * @param transaction The transaction to cap
+ * @param maxAcceptableFee The maximum acceptable fee to pay
+ */
+export declare function capTransactionFee(transaction: algosdk.Transaction, maxAcceptableFee: AlgoAmount): void;
+/**
+ * Returns suggested transaction parameters from algod unless some are already provided.
+ * @param params Optionally provide parameters to use
+ * @param algod Algod algod
+ * @returns The suggested transaction parameters
+ */
+export declare function getTransactionParams(params: SuggestedParams | undefined, algod: Algodv2): Promise<algosdk.SuggestedParams>;
+//# sourceMappingURL=transaction.d.ts.map