@algorandfoundation/algokit-utils 10.0.0-alpha.3 → 10.0.0-alpha.32

package/types/composer.mjs

@@ -1,1572 +1,8 @@
-import { EMPTY_SIGNATURE, MAX_TRANSACTION_GROUP_SIZE } from "../packages/common/src/constants.mjs";
-import { OnApplicationComplete } from "../packages/transact/src/transactions/app-call.mjs";
-import { TransactionType } from "../packages/transact/src/transactions/transaction-type.mjs";
-import { Transaction, assignFee, calculateFee, decodeTransaction, encodeTransactionRaw, groupTransactions } from "../packages/transact/src/transactions/transaction.mjs";
-import { decodeSignedTransaction, encodeSignedTransactions } from "../packages/transact/src/transactions/signed-transaction.mjs";
-import { makeEmptyTransactionSigner } from "../packages/transact/src/signer.mjs";
-import { AlgoAmount } from "./amount.mjs";
-import { Config } from "../config.mjs";
-import { asJson } from "../util.mjs";
-import { waitForConfirmation } from "../transaction/transaction.mjs";
-import { AppManager } from "./app-manager.mjs";
-import { buildAppCall, buildAppCreate, buildAppUpdate, populateGroupResources, populateTransactionResources } from "../transactions/app-call.mjs";
-import { buildAssetOptIn, buildAssetOptOut, buildAssetTransfer } from "../transactions/asset-transfer.mjs";
-import { buildAssetConfig, buildAssetCreate, buildAssetDestroy, buildAssetFreeze } from "../transactions/asset-config.mjs";
-import { FeeDelta, FeePriority, calculateInnerFeeDelta } from "../transactions/fee-coverage.mjs";
-import { buildKeyReg } from "../transactions/key-registration.mjs";
-import { buildAppCallMethodCall, buildAppCreateMethodCall, buildAppUpdateMethodCall, extractComposerTransactionsFromAppMethodCallParams, processAppMethodCallArgs } from "../transactions/method-call.mjs";
-import { buildPayment } from "../transactions/payment.mjs";
-import { EventType } from "./lifecycle-events.mjs";
-import { genesisIdIsLocalNet } from "./network-client.mjs";
-import { Buffer } from "buffer";
+import { TransactionComposer as TransactionComposer$1 } from "../composer.mjs";
 
 //#region src/types/composer.ts
-var InvalidErrorTransformerValue = class extends Error {
-	constructor(originalError, value) {
-		super(`An error transformer returned a non-error value: ${value}. The original error before any transformation: ${originalError}`);
-	}
-};
-var ErrorTransformerError = class extends Error {
-	constructor(originalError, cause) {
-		super(`An error transformer threw an error: ${cause}. The original error before any transformation: ${originalError} `, { cause });
-	}
-};
-/** TransactionComposer helps you compose and execute transactions as a transaction group. */
-var TransactionComposer = class TransactionComposer {
-	/** Transactions that have not yet been composed */
-	txns = [];
-	/** The algod client used by the composer. */
-	algod;
-	/** An async function that will return suggested params for the transaction. */
-	getSuggestedParams;
-	/** A function that takes in an address and return a signer function for that address. */
-	getSigner;
-	/** The default transaction validity window */
-	defaultValidityWindow = 10n;
-	/** Whether the validity window was explicitly set on construction */
-	defaultValidityWindowIsExplicit = false;
-	appManager;
-	errorTransformers;
-	composerConfig;
-	transactionsWithSigners;
-	signedTransactions;
-	rawBuildTransactions;
-	async transformError(originalError) {
-		if (!(originalError instanceof Error)) return originalError;
-		let transformedError = originalError;
-		for (const transformer of this.errorTransformers) try {
-			transformedError = await transformer(transformedError);
-			if (!(transformedError instanceof Error)) return new InvalidErrorTransformerValue(originalError, transformedError);
-		} catch (errorFromTransformer) {
-			return new ErrorTransformerError(originalError, errorFromTransformer);
-		}
-		return transformedError;
-	}
-	validateReferenceParams(params) {
-		if (params.accessReferences && params.accessReferences.length > 0 && (params.appReferences && params.appReferences.length > 0 || params.assetReferences && params.assetReferences.length > 0 || params.boxReferences && params.boxReferences.length > 0)) throw new Error("Cannot specify both `accessReferences` and reference arrays (`appReferences`, `assetReferences`, `boxReferences`).");
-	}
-	/**
-	* Create a `TransactionComposer`.
-	* @param params The configuration for this composer
-	* @returns The `TransactionComposer` instance
-	*/
-	constructor(params) {
-		this.algod = params.algod;
-		const defaultGetSuggestedParams = () => params.algod.suggestedParams();
-		this.getSuggestedParams = params.getSuggestedParams ?? defaultGetSuggestedParams;
-		this.getSigner = params.getSigner;
-		this.defaultValidityWindow = params.defaultValidityWindow ?? this.defaultValidityWindow;
-		this.defaultValidityWindowIsExplicit = params.defaultValidityWindow !== void 0;
-		this.appManager = params.appManager ?? new AppManager(params.algod);
-		this.errorTransformers = params.errorTransformers ?? [];
-		this.composerConfig = params.composerConfig ?? {
-			coverAppCallInnerTransactionFees: false,
-			populateAppCallResources: true
-		};
-	}
-	cloneTransaction(txn) {
-		switch (txn.type) {
-			case "pay": return {
-				type: "pay",
-				data: { ...txn.data }
-			};
-			case "assetCreate": return {
-				type: "assetCreate",
-				data: { ...txn.data }
-			};
-			case "assetConfig": return {
-				type: "assetConfig",
-				data: { ...txn.data }
-			};
-			case "assetFreeze": return {
-				type: "assetFreeze",
-				data: { ...txn.data }
-			};
-			case "assetDestroy": return {
-				type: "assetDestroy",
-				data: { ...txn.data }
-			};
-			case "assetTransfer": return {
-				type: "assetTransfer",
-				data: { ...txn.data }
-			};
-			case "assetOptIn": return {
-				type: "assetOptIn",
-				data: { ...txn.data }
-			};
-			case "assetOptOut": return {
-				type: "assetOptOut",
-				data: { ...txn.data }
-			};
-			case "appCall": return {
-				type: "appCall",
-				data: { ...txn.data }
-			};
-			case "keyReg": return {
-				type: "keyReg",
-				data: { ...txn.data }
-			};
-			case "txn": {
-				const { txn: transaction, signer, maxFee } = txn.data;
-				const clonedTxn = decodeTransaction(encodeTransactionRaw(transaction));
-				delete clonedTxn.group;
-				return {
-					type: "txn",
-					data: {
-						txn: clonedTxn,
-						signer,
-						maxFee
-					}
-				};
-			}
-			case "asyncTxn": {
-				const { txn: txnPromise, signer, maxFee } = txn.data;
-				return {
-					type: "asyncTxn",
-					data: {
-						txn: txnPromise.then((resolvedTxn) => {
-							const clonedTxn = decodeTransaction(encodeTransactionRaw(resolvedTxn));
-							delete clonedTxn.group;
-							return clonedTxn;
-						}),
-						signer,
-						maxFee
-					}
-				};
-			}
-			case "methodCall": return {
-				type: "methodCall",
-				data: { ...txn.data }
-			};
-		}
-	}
-	push(...txns) {
-		if (this.transactionsWithSigners) throw new Error("Cannot add new transactions after building");
-		if (this.txns.length + txns.length > MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Adding ${txns.length} transaction(s) would exceed the maximum group size. Current: ${this.txns.length}, Maximum: ${MAX_TRANSACTION_GROUP_SIZE}`);
-		this.txns.push(...txns);
-	}
-	clone(composerConfig) {
-		const newComposer = new TransactionComposer({
-			algod: this.algod,
-			getSuggestedParams: this.getSuggestedParams,
-			getSigner: this.getSigner,
-			defaultValidityWindow: this.defaultValidityWindow,
-			appManager: this.appManager,
-			errorTransformers: this.errorTransformers,
-			composerConfig: {
-				...this.composerConfig,
-				...composerConfig
-			}
-		});
-		this.txns.forEach((txn) => {
-			newComposer.txns.push(this.cloneTransaction(txn));
-		});
-		newComposer.defaultValidityWindowIsExplicit = this.defaultValidityWindowIsExplicit;
-		return newComposer;
-	}
-	/**
-	* Register a function that will be used to transform an error caught when simulating or executing
-	*
-	* @returns The composer so you can chain method calls
-	*/
-	registerErrorTransformer(transformer) {
-		this.errorTransformers.push(transformer);
-		return this;
-	}
-	/**
-	* Add a pre-built transaction to the transaction group.
-	* @param transaction The pre-built transaction
-	* @param signer Optional signer override for the transaction
-	* @returns The composer so you can chain method calls
-	* @example
-	* ```typescript
-	* composer.addTransaction(txn)
-	* ```
-	*/
-	addTransaction(transaction, signer) {
-		if (transaction.group) throw new Error("Cannot add a transaction to the composer because it is already in a group");
-		this.push({
-			data: {
-				txn: transaction,
-				signer: signer ?? this.getSigner(transaction.sender)
-			},
-			type: "txn"
-		});
-		return this;
-	}
-	/**
-	* Add another transaction composer to the current transaction composer.
-	* The transaction params of the input transaction composer will be added.
-	* If the input transaction composer is updated, it won't affect the current transaction composer.
-	* @param composer The transaction composer to add
-	* @returns The composer so you can chain method calls
-	* @example
-	* ```typescript
-	* const innerComposer = algorand.newGroup()
-	*   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (1).algo() })
-	*   .addPayment({ sender: 'SENDER', receiver: 'RECEIVER', amount: (2).algo() })
-	*
-	* composer.addTransactionComposer(innerComposer)
-	* ```
-	*/
-	addTransactionComposer(composer) {
-		const clonedTxns = composer.txns.map((txn) => this.cloneTransaction(txn));
-		this.push(...clonedTxns);
-		return this;
-	}
-	/**
-	* Add a payment transaction to the transaction group.
-	* @param params The payment transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addPayment({
-	*   sender: 'SENDERADDRESS',
-	*   receiver: 'RECEIVERADDRESS',
-	*   amount: (4).algo(),
-	* })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addPayment({
-	*   amount: (4).algo(),
-	*   receiver: 'RECEIVERADDRESS',
-	*   sender: 'SENDERADDRESS',
-	*   closeRemainderTo: 'CLOSEREMAINDERTOADDRESS',
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-	*   rekeyTo: 'REKEYTOADDRESS',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	*/
-	addPayment(params) {
-		this.push({
-			data: params,
-			type: "pay"
-		});
-		return this;
-	}
-	/**
-	* Add an asset create transaction to the transaction group.
-	* @param params The asset create transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetCreate({ sender: "CREATORADDRESS", total: 100n})
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetCreate({
-	*   sender: 'CREATORADDRESS',
-	*   total: 100n,
-	*   decimals: 2,
-	*   assetName: 'asset',
-	*   unitName: 'unit',
-	*   url: 'url',
-	*   metadataHash: 'metadataHash',
-	*   defaultFrozen: false,
-	*   manager: 'MANAGERADDRESS',
-	*   reserve: 'RESERVEADDRESS',
-	*   freeze: 'FREEZEADDRESS',
-	*   clawback: 'CLAWBACKADDRESS',
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	*/
-	addAssetCreate(params) {
-		this.push({
-			data: params,
-			type: "assetCreate"
-		});
-		return this;
-	}
-	/**
-	* Add an asset config transaction to the transaction group.
-	* @param params The asset config transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetConfig({
-	*   sender: 'MANAGERADDRESS',
-	*   assetId: 123456n,
-	*   manager: 'MANAGERADDRESS',
-	*   reserve: 'RESERVEADDRESS',
-	*   freeze: 'FREEZEADDRESS',
-	*   clawback: 'CLAWBACKADDRESS',
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	*/
-	addAssetConfig(params) {
-		this.push({
-			data: params,
-			type: "assetConfig"
-		});
-		return this;
-	}
-	/**
-	* Add an asset freeze transaction to the transaction group.
-	* @param params The asset freeze transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetFreeze({
-	*   sender: 'MANAGERADDRESS',
-	*   assetId: 123456n,
-	*   account: 'ACCOUNTADDRESS',
-	*   frozen: true,
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addAssetFreeze(params) {
-		this.push({
-			data: params,
-			type: "assetFreeze"
-		});
-		return this;
-	}
-	/**
-	* Add an asset destroy transaction to the transaction group.
-	* @param params The asset destroy transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetDestroy({
-	*   sender: 'MANAGERADDRESS',
-	*   assetId: 123456n,
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addAssetDestroy(params) {
-		this.push({
-			data: params,
-			type: "assetDestroy"
-		});
-		return this;
-	}
-	/**
-	* Add an asset transfer transaction to the transaction group.
-	* @param params The asset transfer transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
-	* ```
-	* @example Advanced example (with clawback)
-	* ```typescript
-	* composer.addAssetTransfer({
-	*   sender: 'CLAWBACKADDRESS',
-	*   assetId: 123456n,
-	*   amount: 1n,
-	*   receiver: 'RECEIVERADDRESS',
-	*   clawbackTarget: 'HOLDERADDRESS',
-	*   // This field needs to be used with caution
-	*   closeAssetTo: 'ADDRESSTOCLOSETO'
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addAssetTransfer(params) {
-		this.push({
-			data: params,
-			type: "assetTransfer"
-		});
-		return this;
-	}
-	/**
-	* Add an asset opt-in transaction to the transaction group.
-	* @param params The asset opt-in transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAssetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetOptIn({
-	*   sender: 'SENDERADDRESS',
-	*   assetId: 123456n,
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addAssetOptIn(params) {
-		this.push({
-			data: params,
-			type: "assetOptIn"
-		});
-		return this;
-	}
-	/**
-	* Add an asset opt-out transaction to the transaction group.
-	* @param params The asset opt-out transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example (without creator, will be retrieved from algod)
-	* ```typescript
-	* composer.addAssetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
-	* ```
-	* @example Basic example (with creator)
-	* ```typescript
-	* composer.addAssetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAssetOptOut({
-	*   sender: 'SENDERADDRESS',
-	*   assetId: 123456n,
-	*   creator: 'CREATORADDRESS',
-	*   ensureZeroBalance: true,
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addAssetOptOut(params) {
-		this.push({
-			data: params,
-			type: "assetOptOut"
-		});
-		return this;
-	}
-	/**
-	* Add an application create transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The application create transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAppCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAppCreate({
-	*  sender: 'CREATORADDRESS',
-	*  approvalProgram: "TEALCODE",
-	*  clearStateProgram: "TEALCODE",
-	*  schema: {
-	*    globalInts: 1,
-	*    globalByteSlices: 2,
-	*    localInts: 3,
-	*    localByteSlices: 4
-	*  },
-	*  extraProgramPages: 1,
-	*  onComplete: OnApplicationComplete.OptIn,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*  // Signer only needed if you want to provide one,
-	*  //  generally you'd register it with AlgorandClient
-	*  //  against the sender and not need to pass it in
-	*  signer: transactionSigner,
-	*  maxRoundsToWaitForConfirmation: 5,
-	*  suppressLog: true,
-	*})
-	* ```
-	*/
-	addAppCreate(params) {
-		this.validateReferenceParams(params);
-		this.push({
-			data: params,
-			type: "appCall"
-		});
-		return this;
-	}
-	/**
-	* Add an application update transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The application update transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAppUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAppUpdate({
-	*  sender: 'CREATORADDRESS',
-	*  approvalProgram: "TEALCODE",
-	*  clearStateProgram: "TEALCODE",
-	*  onComplete: OnApplicationComplete.UpdateApplication,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppUpdate(params) {
-		this.validateReferenceParams(params);
-		this.push({
-			data: {
-				...params,
-				onComplete: OnApplicationComplete.UpdateApplication
-			},
-			type: "appCall"
-		});
-		return this;
-	}
-	/**
-	* Add an application delete transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The application delete transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAppDelete({ sender: 'CREATORADDRESS' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAppDelete({
-	*  sender: 'CREATORADDRESS',
-	*  onComplete: OnApplicationComplete.DeleteApplication,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppDelete(params) {
-		this.validateReferenceParams(params);
-		this.push({
-			data: {
-				...params,
-				onComplete: OnApplicationComplete.DeleteApplication
-			},
-			type: "appCall"
-		});
-		return this;
-	}
-	/**
-	* Add an application call transaction to the transaction group.
-	*
-	* If you want to create or update an app use `addAppCreate` or `addAppUpdate`.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The application call transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addAppCall({ sender: 'CREATORADDRESS' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addAppCall({
-	*  sender: 'CREATORADDRESS',
-	*  onComplete: OnApplicationComplete.OptIn,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppCall(params) {
-		this.validateReferenceParams(params);
-		this.push({
-			data: params,
-			type: "appCall"
-		});
-		return this;
-	}
-	/**
-	* Add an ABI method create application call transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The ABI create method application call transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppCreateMethodCall({
-	*  sender: 'CREATORADDRESS',
-	*  method: method,
-	*  args: ["arg1_value"],
-	*  approvalProgram: "TEALCODE",
-	*  clearStateProgram: "TEALCODE",
-	*  schema: {
-	*    globalInts: 1,
-	*    globalByteSlices: 2,
-	*    localInts: 3,
-	*    localByteSlices: 4
-	*  },
-	*  extraProgramPages: 1,
-	*  onComplete: OnApplicationComplete.OptIn,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppCreateMethodCall(params) {
-		this.validateReferenceParams(params);
-		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
-		this.push(...txnArgs, {
-			data: {
-				...params,
-				args: processAppMethodCallArgs(params.args)
-			},
-			type: "methodCall"
-		});
-		return this;
-	}
-	/**
-	* Add an ABI method update application call transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The ABI update method application call transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppUpdateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppUpdateMethodCall({
-	*  sender: 'CREATORADDRESS',
-	*  method: method,
-	*  args: ["arg1_value"],
-	*  approvalProgram: "TEALCODE",
-	*  clearStateProgram: "TEALCODE",
-	*  onComplete: OnApplicationComplete.UpdateApplication,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppUpdateMethodCall(params) {
-		this.validateReferenceParams(params);
-		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
-		this.push(...txnArgs, {
-			data: {
-				...params,
-				args: processAppMethodCallArgs(params.args),
-				onComplete: OnApplicationComplete.UpdateApplication
-			},
-			type: "methodCall"
-		});
-		return this;
-	}
-	/**
-	* Add an ABI method delete application call transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The ABI delete method application call transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppDeleteMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppDeleteMethodCall({
-	*  sender: 'CREATORADDRESS',
-	*  method: method,
-	*  args: ["arg1_value"],
-	*  onComplete: OnApplicationComplete.DeleteApplication,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppDeleteMethodCall(params) {
-		this.validateReferenceParams(params);
-		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
-		this.push(...txnArgs, {
-			data: {
-				...params,
-				args: processAppMethodCallArgs(params.args),
-				onComplete: OnApplicationComplete.DeleteApplication
-			},
-			type: "methodCall"
-		});
-		return this;
-	}
-	/**
-	* Add a non-create/non-update ABI method application call transaction to the transaction group.
-	*
-	* Note: we recommend using app clients to make it easier to make app calls.
-	* @param params The ABI method application call transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppCallMethodCall({ sender: 'CREATORADDRESS', method: method, args: ["arg1_value"] })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* composer.addAppCallMethodCall({
-	*  sender: 'CREATORADDRESS',
-	*  method: method,
-	*  args: ["arg1_value"],
-	*  onComplete: OnApplicationComplete.OptIn,
-	*  args: [new Uint8Array(1, 2, 3, 4)]
-	*  accountReferences: ["ACCOUNT_1"]
-	*  appReferences: [123n, 1234n]
-	*  assetReferences: [12345n]
-	*  boxReferences: ["box1", {appId: 1234n, name: "box2"}]
-	*  accessReferences: [{ appId: 1234n }]
-	*  lease: 'lease',
-	*  note: 'note',
-	*  // You wouldn't normally set this field
-	*  firstValidRound: 1000n,
-	*  validityWindow: 10,
-	*  extraFee: (1000).microAlgo(),
-	*  staticFee: (1000).microAlgo(),
-	*  // Max fee doesn't make sense with extraFee AND staticFee
-	*  //  already specified, but here for completeness
-	*  maxFee: (3000).microAlgo(),
-	*})
-	* ```
-	*/
-	addAppCallMethodCall(params) {
-		this.validateReferenceParams(params);
-		const txnArgs = extractComposerTransactionsFromAppMethodCallParams(params);
-		this.push(...txnArgs, {
-			data: {
-				...params,
-				args: processAppMethodCallArgs(params.args)
-			},
-			type: "methodCall"
-		});
-		return this;
-	}
-	/**
-	* Add an online key registration transaction to the transaction group.
-	* @param params The online key registration transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addOnlineKeyRegistration({
-	*   sender: 'SENDERADDRESS',
-	*   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
-	*   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
-	*   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
-	*   voteFirst: 1n,
-	*   voteLast: 1000n,
-	*   voteKeyDilution: 1n,
-	* })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addOnlineKeyRegistration({
-	*   sender: 'SENDERADDRESS',
-	*   voteKey: Uint8Array.from(Buffer.from("voteKeyBase64", 'base64')),
-	*   selectionKey: Uint8Array.from(Buffer.from("selectionKeyBase64", 'base64')),
-	*   stateProofKey: Uint8Array.from(Buffer.from("stateProofKeyBase64", 'base64')),
-	*   voteFirst: 1n,
-	*   voteLast: 1000n,
-	*   voteKeyDilution: 1n,
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-	*   rekeyTo: 'REKEYTOADDRESS',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addOnlineKeyRegistration(params) {
-		this.push({
-			data: params,
-			type: "keyReg"
-		});
-		return this;
-	}
-	/**
-	* Add an offline key registration transaction to the transaction group.
-	* @param params The offline key registration transaction parameters
-	* @returns The composer so you can chain method calls
-	* @example Basic example
-	* ```typescript
-	* composer.addOfflineKeyRegistration({
-	*   sender: 'SENDERADDRESS',
-	* })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* composer.addOfflineKeyRegistration({
-	*   sender: 'SENDERADDRESS',
-	*   lease: 'lease',
-	*   note: 'note',
-	*   // Use this with caution, it's generally better to use algorand.account.rekeyAccount
-	*   rekeyTo: 'REKEYTOADDRESS',
-	*   // You wouldn't normally set this field
-	*   firstValidRound: 1000n,
-	*   validityWindow: 10,
-	*   extraFee: (1000).microAlgo(),
-	*   staticFee: (1000).microAlgo(),
-	*   // Max fee doesn't make sense with extraFee AND staticFee
-	*   //  already specified, but here for completeness
-	*   maxFee: (3000).microAlgo(),
-	* })
-	* ```
-	*/
-	addOfflineKeyRegistration(params) {
-		this.push({
-			data: params,
-			type: "keyReg"
-		});
-		return this;
-	}
-	/**
-	* Get the number of transactions currently added to this composer.
-	* @returns The number of transactions currently added to this composer
-	*/
-	count() {
-		return this.txns.length;
-	}
-	/**
-	* Build the transaction composer.
-	*
-	* This method performs resource population and inner transaction fee coverage if these options are set in the composer.
-	*
-	* Once this method is called, no further transactions will be able to be added.
-	* You can safely call this method multiple times to get the same result.
-	* @returns The built transaction composer, the transactions and any corresponding method calls
-	* @example
-	* ```typescript
-	* const { transactions, methodCalls } = await composer.build()
-	* ```
-	*/
-	async build() {
-		if (!this.transactionsWithSigners) {
-			const suggestedParams = await this.getSuggestedParams();
-			const builtTransactions = await this._buildTransactions(suggestedParams);
-			this.rawBuildTransactions = builtTransactions.transactions;
-			const groupAnalysis = (this.composerConfig.coverAppCallInnerTransactionFees || this.composerConfig.populateAppCallResources) && builtTransactions.transactions.some((txn) => txn.type === TransactionType.AppCall) ? await this.analyzeGroupRequirements(builtTransactions.transactions, suggestedParams, this.composerConfig) : void 0;
-			this.populateTransactionAndGroupResources(builtTransactions.transactions, groupAnalysis);
-			this.transactionsWithSigners = builtTransactions.transactions.map((txn, index) => {
-				return {
-					txn,
-					signer: builtTransactions.signers.get(index) ?? this.getSigner(txn.sender)
-				};
-			});
-		}
-		const methodCalls = /* @__PURE__ */ new Map();
-		this.txns.forEach((txn, index) => {
-			if (txn.type === "methodCall") methodCalls.set(index, txn.data.method);
-		});
-		return {
-			transactions: this.transactionsWithSigners,
-			methodCalls
-		};
-	}
-	async _buildTransactions(suggestedParams) {
-		const defaultValidityWindow = !this.defaultValidityWindowIsExplicit && genesisIdIsLocalNet(suggestedParams.genesisId ?? "unknown") ? 1000n : this.defaultValidityWindow;
-		const signers = /* @__PURE__ */ new Map();
-		const transactions = new Array();
-		let transactionIndex = 0;
-		for (const ctxn of this.txns) if (ctxn.type === "txn") {
-			transactions.push(ctxn.data.txn);
-			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
-			transactionIndex++;
-		} else if (ctxn.type === "asyncTxn") {
-			transactions.push(await ctxn.data.txn);
-			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
-			transactionIndex++;
-		} else {
-			let transaction;
-			switch (ctxn.type) {
-				case "pay":
-					transaction = buildPayment(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetCreate":
-					transaction = buildAssetCreate(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetConfig":
-					transaction = buildAssetConfig(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetFreeze":
-					transaction = buildAssetFreeze(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetDestroy":
-					transaction = buildAssetDestroy(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetTransfer":
-					transaction = buildAssetTransfer(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetOptIn":
-					transaction = buildAssetOptIn(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "assetOptOut":
-					transaction = buildAssetOptOut(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "appCall":
-					if (!("appId" in ctxn.data)) transaction = await buildAppCreate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
-					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await buildAppUpdate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
-					else transaction = buildAppCall(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "keyReg":
-					transaction = buildKeyReg(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				case "methodCall":
-					if (!("appId" in ctxn.data)) transaction = await buildAppCreateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
-					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await buildAppUpdateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
-					else transaction = await buildAppCallMethodCall(ctxn.data, suggestedParams, defaultValidityWindow);
-					break;
-				default: throw new Error(`Unsupported transaction type: ${ctxn.type}`);
-			}
-			if (transaction.fee === void 0) transaction = assignFee(transaction, {
-				feePerByte: suggestedParams.fee,
-				minFee: suggestedParams.minFee,
-				extraFee: ctxn.data.extraFee?.microAlgos,
-				maxFee: ctxn.data.maxFee?.microAlgos
-			});
-			transactions.push(transaction);
-			if (ctxn.data.signer) {
-				const signer = "signer" in ctxn.data.signer ? ctxn.data.signer.signer : ctxn.data.signer;
-				signers.set(transactionIndex, signer);
-			}
-			transactionIndex++;
-		}
-		if (transactions.length > MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Transaction group size ${transactions.length} exceeds the maximum limit of ${MAX_TRANSACTION_GROUP_SIZE}`);
-		const methodCalls = /* @__PURE__ */ new Map();
-		this.txns.forEach((txn, index) => {
-			if (txn.type === "methodCall") methodCalls.set(index, txn.data.method);
-		});
-		return {
-			transactions,
-			methodCalls,
-			signers
-		};
-	}
-	/**
-	* Builds all transactions in the composer and returns them along with method calls and signers.
-	*
-	* Note: This method only builds the transactions as-is without resource population or automatic grouping.
-	* Use this when you need the raw transactions.
-	* @returns An object containing the array of built transactions, method calls, and signers
-	* @example
-	* ```typescript
-	* const { transactions, methodCalls, signers } = await composer.buildTransactions()
-	* ```
-	*/
-	async buildTransactions() {
-		const suggestedParams = await this.getSuggestedParams();
-		const buildResult = await this._buildTransactions(suggestedParams);
-		return {
-			...buildResult,
-			transactions: buildResult.transactions
-		};
-	}
-	populateTransactionAndGroupResources(transactions, groupAnalysis) {
-		if (groupAnalysis) {
-			let surplusGroupFees = 0n;
-			const transactionAnalysis = [];
-			groupAnalysis.transactions.forEach((txnAnalysis, groupIndex) => {
-				if (txnAnalysis.requiredFeeDelta && FeeDelta.isSurplus(txnAnalysis.requiredFeeDelta)) surplusGroupFees += FeeDelta.amount(txnAnalysis.requiredFeeDelta);
-				const ctxn = this.txns[groupIndex];
-				const txn = transactions[groupIndex];
-				const logicalMaxFee = getLogicalMaxFee(ctxn);
-				const isImmutableFee = logicalMaxFee !== void 0 && logicalMaxFee === (txn.fee || 0n);
-				let priority = FeePriority.Covered;
-				if (txnAnalysis.requiredFeeDelta && FeeDelta.isDeficit(txnAnalysis.requiredFeeDelta)) {
-					const deficitAmount = FeeDelta.amount(txnAnalysis.requiredFeeDelta);
-					if (isImmutableFee || txn.type !== TransactionType.AppCall) priority = FeePriority.ImmutableDeficit(deficitAmount);
-					else priority = FeePriority.ModifiableDeficit(deficitAmount);
-				}
-				transactionAnalysis.push({
-					groupIndex,
-					requiredFeeDelta: txnAnalysis.requiredFeeDelta,
-					priority,
-					unnamedResourcesAccessed: txnAnalysis.unnamedResourcesAccessed
-				});
-			});
-			transactionAnalysis.sort((a, b) => b.priority.compare(a.priority));
-			const indexesWithAccessReferences = [];
-			for (const { groupIndex, requiredFeeDelta, unnamedResourcesAccessed } of transactionAnalysis) {
-				if (requiredFeeDelta && FeeDelta.isDeficit(requiredFeeDelta)) {
-					const deficitAmount = FeeDelta.amount(requiredFeeDelta);
-					let additionalFeeDelta;
-					if (surplusGroupFees === 0n) additionalFeeDelta = requiredFeeDelta;
-					else if (surplusGroupFees >= deficitAmount) surplusGroupFees -= deficitAmount;
-					else {
-						additionalFeeDelta = FeeDelta.fromBigInt(deficitAmount - surplusGroupFees);
-						surplusGroupFees = 0n;
-					}
-					if (additionalFeeDelta && FeeDelta.isDeficit(additionalFeeDelta)) {
-						const additionalDeficitAmount = FeeDelta.amount(additionalFeeDelta);
-						if (transactions[groupIndex].type === TransactionType.AppCall) {
-							const transactionFee = (transactions[groupIndex].fee || 0n) + additionalDeficitAmount;
-							const logicalMaxFee = getLogicalMaxFee(this.txns[groupIndex]);
-							if (!logicalMaxFee || transactionFee > logicalMaxFee) throw new Error(`Calculated transaction fee ${transactionFee} µALGO is greater than max of ${logicalMaxFee ?? 0n} for transaction ${groupIndex}`);
-							transactions[groupIndex].fee = transactionFee;
-						} else throw new Error(`An additional fee of ${additionalDeficitAmount} µALGO is required for non app call transaction ${groupIndex}`);
-					}
-				}
-				if (unnamedResourcesAccessed && transactions[groupIndex].type === TransactionType.AppCall) if (!(transactions[groupIndex].appCall?.accessReferences && transactions[groupIndex].appCall?.accessReferences?.length)) populateTransactionResources(transactions[groupIndex], unnamedResourcesAccessed, groupIndex);
-				else indexesWithAccessReferences.push(groupIndex);
-			}
-			if (indexesWithAccessReferences.length > 0) Config.logger.warn(`Resource population will be skipped for transaction indexes ${indexesWithAccessReferences.join(", ")} as they use access references.`);
-			if (groupAnalysis.unnamedResourcesAccessed) populateGroupResources(transactions, groupAnalysis.unnamedResourcesAccessed);
-		}
-		if (transactions.length > 1) {
-			const groupedTransactions = groupTransactions(transactions);
-			transactions.forEach((t) => t.group = groupedTransactions[0].group);
-			return transactions;
-		} else return transactions;
-	}
-	async analyzeGroupRequirements(transactions, suggestedParams, analysisParams) {
-		const appCallIndexesWithoutMaxFees = [];
-		let transactionsToSimulate = transactions.map((txn, groupIndex) => {
-			const ctxn = this.txns[groupIndex];
-			const params = { ...txn };
-			delete params.group;
-			if (analysisParams.coverAppCallInnerTransactionFees && txn.type === TransactionType.AppCall) {
-				const logicalMaxFee = getLogicalMaxFee(ctxn);
-				if (logicalMaxFee !== void 0) params.fee = logicalMaxFee;
-				else appCallIndexesWithoutMaxFees.push(groupIndex);
-			}
-			return new Transaction(params);
-		});
-		if (transactionsToSimulate.length > 1) transactionsToSimulate = groupTransactions(transactionsToSimulate);
-		if (analysisParams.coverAppCallInnerTransactionFees && appCallIndexesWithoutMaxFees.length > 0) throw new Error(`Please provide a maxFee for each app call transaction when coverAppCallInnerTransactionFees is enabled. Required for transaction ${appCallIndexesWithoutMaxFees.join(", ")}`);
-		const simulateRequest = {
-			txnGroups: [{ txns: transactionsToSimulate.map((txn) => ({
-				txn,
-				sig: EMPTY_SIGNATURE
-			})) }],
-			allowUnnamedResources: true,
-			allowEmptySignatures: true,
-			fixSigners: true,
-			allowMoreLogging: true,
-			execTraceConfig: {
-				enable: true,
-				scratchChange: true,
-				stackChange: true,
-				stateChange: true
-			}
-		};
-		const groupResponse = (await this.algod.simulateTransactions(simulateRequest)).txnGroups[0];
-		if (groupResponse.failureMessage) {
-			if (analysisParams.coverAppCallInnerTransactionFees && groupResponse.failureMessage.includes("fee too small")) throw new Error("Fees were too small to resolve execution info via simulate. You may need to increase an app call transaction maxFee.");
-			throw new Error(`Error resolving execution info via simulate in transaction ${groupResponse.failedAt?.join(", ")}: ${groupResponse.failureMessage}`);
-		}
-		const txnAnalysisResults = groupResponse.txnResults.map((simulateTxnResult, groupIndex) => {
-			const btxn = transactions[groupIndex];
-			let requiredFeeDelta;
-			if (analysisParams.coverAppCallInnerTransactionFees) {
-				const minTxnFee = calculateFee(btxn, {
-					feePerByte: suggestedParams.fee,
-					minFee: suggestedParams.minFee
-				});
-				const txnFeeDelta = FeeDelta.fromBigInt(minTxnFee - (btxn.fee ?? 0n));
-				if (btxn.type === TransactionType.AppCall) {
-					const innerTxnsFeeDelta = calculateInnerFeeDelta(simulateTxnResult.txnResult.innerTxns, suggestedParams.minFee);
-					requiredFeeDelta = FeeDelta.fromBigInt((innerTxnsFeeDelta ? FeeDelta.toBigInt(innerTxnsFeeDelta) : 0n) + (txnFeeDelta ? FeeDelta.toBigInt(txnFeeDelta) : 0n));
-				} else requiredFeeDelta = txnFeeDelta;
-			}
-			return {
-				requiredFeeDelta,
-				unnamedResourcesAccessed: analysisParams.populateAppCallResources ? simulateTxnResult.unnamedResourcesAccessed : void 0
-			};
-		});
-		const sortedResources = groupResponse.unnamedResourcesAccessed;
-		const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
-		if (sortedResources) {
-			sortedResources.accounts?.sort((a, b) => compare(a.toString(), b.toString()));
-			sortedResources.assets?.sort(compare);
-			sortedResources.apps?.sort(compare);
-			sortedResources.boxes?.sort((a, b) => {
-				return compare(`${a.app}-${a.name}`, `${b.app}-${b.name}`);
-			});
-			sortedResources.appLocals?.sort((a, b) => {
-				return compare(`${a.app}-${a.account}`, `${b.app}-${b.account}`);
-			});
-			sortedResources.assetHoldings?.sort((a, b) => {
-				return compare(`${a.asset}-${a.account}`, `${b.asset}-${b.account}`);
-			});
-		}
-		return {
-			transactions: txnAnalysisResults,
-			unnamedResourcesAccessed: analysisParams.populateAppCallResources ? sortedResources : void 0
-		};
-	}
-	/**
-	* Rebuild the group, discarding any previously built transactions.
-	* This will potentially cause new signers and suggested params to be used if the callbacks return a new value compared to the first build.
-	* @returns The newly built transaction composer and the transactions
-	* @example
-	* ```typescript
-	* const { atc, transactions, methodCalls } = await composer.rebuild()
-	* ```
-	*/
-	async rebuild() {
-		this.reset();
-		return await this.build();
-	}
-	reset() {
-		this.signedTransactions = void 0;
-		this.transactionsWithSigners = void 0;
-	}
-	/**
-	* Compose the transaction group and send it to the network.
-	* @param params The parameters to control execution with
-	* @returns The execution result
-	* @example
-	* ```typescript
-	* const result = await composer.send()
-	* ```
-	*/
-	async send(params) {
-		if (this.composerConfig.coverAppCallInnerTransactionFees !== (params?.coverAppCallInnerTransactionFees ?? false) || this.composerConfig.populateAppCallResources !== (params?.populateAppCallResources ?? true)) {
-			this.composerConfig = {
-				coverAppCallInnerTransactionFees: params?.coverAppCallInnerTransactionFees ?? false,
-				populateAppCallResources: params?.populateAppCallResources ?? true
-			};
-			this.reset();
-		}
-		try {
-			await this.gatherSignatures();
-			if (!this.transactionsWithSigners || this.transactionsWithSigners.length === 0 || !this.signedTransactions || this.signedTransactions.length === 0) throw new Error("No transactions available");
-			const transactionsToSend = this.transactionsWithSigners.map((stxn) => stxn.txn);
-			const transactionIds = transactionsToSend.map((txn) => txn.txId());
-			if (transactionsToSend.length > 1) {
-				const groupId = transactionsToSend[0].group ? Buffer.from(transactionsToSend[0].group).toString("base64") : "";
-				Config.getLogger(params?.suppressLog).verbose(`Sending group of ${transactionsToSend.length} transactions (${groupId})`, { transactionsToSend });
-				Config.getLogger(params?.suppressLog).debug(`Transaction IDs (${groupId})`, transactionIds);
-			}
-			if (Config.debug && Config.traceAll) await this.simulate({
-				allowEmptySignatures: true,
-				fixSigners: true,
-				allowMoreLogging: true,
-				execTraceConfig: {
-					enable: true,
-					scratchChange: true,
-					stackChange: true,
-					stateChange: true
-				},
-				resultOnFailure: true
-			});
-			const group = this.signedTransactions[0].txn.group;
-			let waitRounds = params?.maxRoundsToWaitForConfirmation;
-			if (waitRounds === void 0) {
-				const firstRound = (await this.getSuggestedParams()).firstValid;
-				const lastRound = this.signedTransactions.reduce((max, txn) => txn.txn.lastValid > max ? txn.txn.lastValid : max, 0n);
-				waitRounds = Number(lastRound - firstRound) + 1;
-			}
-			const encodedTxns = encodeSignedTransactions(this.signedTransactions);
-			await this.algod.sendRawTransaction(encodedTxns);
-			if (transactionsToSend.length > 1 && group) Config.getLogger(params?.suppressLog).verbose(`Group transaction (${Buffer.from(group).toString("base64")}) sent with ${transactionsToSend.length} transactions`);
-			else Config.getLogger(params?.suppressLog).verbose(`Sent transaction ID ${transactionsToSend[0].txId()} ${transactionsToSend[0].type} from ${transactionsToSend[0].sender}`);
-			let confirmations = new Array();
-			if (params?.maxRoundsToWaitForConfirmation !== 0) confirmations = await Promise.all(transactionIds.map(async (id) => await waitForConfirmation(id, waitRounds, this.algod)));
-			const abiReturns = this.parseAbiReturnValues(confirmations);
-			return {
-				groupId: group ? Buffer.from(group).toString("base64") : void 0,
-				transactions: transactionsToSend,
-				txIds: transactionIds,
-				returns: abiReturns,
-				confirmations
-			};
-		} catch (originalError) {
-			const errorMessage = originalError.body?.message ?? originalError.message ?? "Received error executing Transaction Composer";
-			const err = new Error(errorMessage);
-			err.cause = originalError;
-			if (typeof originalError === "object") err.name = originalError.name;
-			let sentTransactions;
-			if (this.transactionsWithSigners) sentTransactions = this.transactionsWithSigners.map((t) => t.txn);
-			else if (this.rawBuildTransactions) sentTransactions = this.rawBuildTransactions.length > 1 ? groupTransactions(this.rawBuildTransactions) : this.rawBuildTransactions;
-			if (Config.debug && typeof originalError === "object" && sentTransactions) {
-				err.traces = [];
-				Config.getLogger(params?.suppressLog).error("Received error executing Transaction Composer and debug flag enabled; attempting simulation to get more information", err);
-				const transactionsWithEmptySigners = sentTransactions.map((txn) => ({
-					txn,
-					signer: makeEmptyTransactionSigner()
-				}));
-				const signedTransactions = await this.signTransactions(transactionsWithEmptySigners);
-				const simulateResponse = await this.algod.simulateTransactions({
-					txnGroups: [{ txns: signedTransactions }],
-					allowEmptySignatures: true,
-					fixSigners: true,
-					allowMoreLogging: true,
-					execTraceConfig: {
-						enable: true,
-						scratchChange: true,
-						stackChange: true,
-						stateChange: true
-					}
-				});
-				if (Config.debug && !Config.traceAll) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateResponse });
-				if (simulateResponse && simulateResponse.txnGroups[0].failedAt) for (const txn of simulateResponse.txnGroups[0].txnResults) err.traces.push({
-					trace: txn.execTrace,
-					appBudget: txn.appBudgetConsumed,
-					logicSigBudget: txn.logicSigBudgetConsumed,
-					logs: txn.txnResult.logs,
-					message: simulateResponse.txnGroups[0].failureMessage
-				});
-			} else Config.getLogger(params?.suppressLog).error("Received error executing Transaction Composer, for more information enable the debug flag", err);
-			err.sentTransactions = sentTransactions ?? [];
-			throw await this.transformError(err);
-		}
-	}
-	async simulate(options) {
-		const { skipSignatures = false, resultOnFailure = false,...rawOptions } = options ?? {};
-		if (skipSignatures) {
-			rawOptions.allowEmptySignatures = true;
-			rawOptions.fixSigners = true;
-		}
-		let transactionsWithSigner;
-		if (!this.transactionsWithSigners) {
-			const builtTransactions = await this.buildTransactions();
-			transactionsWithSigner = (builtTransactions.transactions.length > 0 ? groupTransactions(builtTransactions.transactions) : builtTransactions.transactions).map((txn, index) => ({
-				txn,
-				signer: skipSignatures ? makeEmptyTransactionSigner() : builtTransactions.signers.get(index) ?? makeEmptyTransactionSigner()
-			}));
-		} else transactionsWithSigner = this.transactionsWithSigners.map((e) => ({
-			txn: e.txn,
-			signer: skipSignatures ? makeEmptyTransactionSigner() : e.signer
-		}));
-		const transactions = transactionsWithSigner.map((e) => e.txn);
-		const simulateRequest = {
-			txnGroups: [{ txns: await this.signTransactions(transactionsWithSigner) }],
-			...rawOptions,
-			...Config.debug ? {
-				allowEmptySignatures: true,
-				fixSigners: true,
-				allowMoreLogging: true,
-				execTraceConfig: {
-					enable: true,
-					scratchChange: true,
-					stackChange: true,
-					stateChange: true
-				}
-			} : void 0
-		};
-		const simulateResponse = await this.algod.simulateTransactions(simulateRequest);
-		const simulateResult = simulateResponse.txnGroups[0];
-		if (simulateResult?.failureMessage && !resultOnFailure) {
-			const errorMessage = `Transaction failed at transaction(s) ${simulateResult.failedAt?.join(", ") || "unknown"} in the group. ${simulateResult.failureMessage}`;
-			const error = new Error(errorMessage);
-			if (Config.debug) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateTransaction: simulateResponse });
-			throw await this.transformError(error);
-		}
-		if (Config.debug && Config.traceAll) await Config.events.emitAsync(EventType.TxnGroupSimulated, { simulateTransaction: simulateResponse });
-		const abiReturns = this.parseAbiReturnValues(simulateResult.txnResults.map((t) => t.txnResult));
-		return {
-			confirmations: simulateResult.txnResults.map((t) => t.txnResult),
-			transactions,
-			txIds: transactions.map((t) => t.txId()),
-			groupId: Buffer.from(transactions[0].group ?? new Uint8Array()).toString("base64"),
-			simulateResponse,
-			returns: abiReturns
-		};
-	}
-	/**
-	* Create an encoded transaction note that follows the ARC-2 spec.
-	*
-	* https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0002.md
-	* @param note The ARC-2 transaction note data
-	* @returns The binary encoded transaction note
-	*/
-	static arc2Note(note) {
-		const arc2Payload = `${note.dAppName}:${note.format}${typeof note.data === "string" ? note.data : asJson(note.data)}`;
-		return new TextEncoder().encode(arc2Payload);
-	}
-	async gatherSignatures() {
-		if (this.signedTransactions) return this.signedTransactions;
-		await this.build();
-		if (!this.transactionsWithSigners || this.transactionsWithSigners.length === 0) throw new Error("No transactions available to sign");
-		this.signedTransactions = await this.signTransactions(this.transactionsWithSigners);
-		return this.signedTransactions;
-	}
-	async signTransactions(transactionsWithSigners) {
-		if (transactionsWithSigners.length === 0) throw new Error("No transactions available to sign");
-		const transactions = transactionsWithSigners.map((txnWithSigner) => txnWithSigner.txn);
-		const signerGroups = /* @__PURE__ */ new Map();
-		transactionsWithSigners.forEach(({ signer }, index) => {
-			const indexes = signerGroups.get(signer) ?? [];
-			indexes.push(index);
-			signerGroups.set(signer, indexes);
-		});
-		const signerEntries = Array.from(signerGroups);
-		const signedGroups = await Promise.all(signerEntries.map(([signer, indexes]) => signer(transactions, indexes)));
-		const signedTransactions = new Array(transactionsWithSigners.length);
-		signerEntries.forEach(([, indexes], signerIndex) => {
-			const stxs = signedGroups[signerIndex];
-			indexes.forEach((txIndex, stxIndex) => {
-				signedTransactions[txIndex] = decodeSignedTransaction(stxs[stxIndex]);
-			});
-		});
-		const unsignedIndexes = signedTransactions.map((stxn, index) => stxn === void 0 ? index : null).filter((index) => index !== null);
-		if (unsignedIndexes.length > 0) throw new Error(`Transactions at indexes [${unsignedIndexes.join(", ")}] were not signed`);
-		return signedTransactions;
-	}
-	parseAbiReturnValues(confirmations) {
-		const abiReturns = new Array();
-		for (let i = 0; i < confirmations.length; i++) {
-			const confirmation = confirmations[i];
-			const txn = this.txns[i];
-			if (txn?.type !== "methodCall") continue;
-			const method = txn.data.method;
-			if (method.returns.type !== "void") {
-				const abiReturn = AppManager.getABIReturn(confirmation, method);
-				if (abiReturn !== void 0) abiReturns.push(abiReturn);
-			}
-		}
-		return abiReturns;
-	}
-	setMaxFees(maxFees) {
-		maxFees.forEach((_, index) => {
-			if (index > this.txns.length - 1) throw new Error(`Index ${index} is out of range. The composer only contains ${this.txns.length} transactions`);
-		});
-		maxFees.forEach((maxFee, index) => {
-			this.txns[index].data.maxFee = new AlgoAmount({ microAlgos: maxFee.microAlgos });
-		});
-	}
-};
-/** Get the logical maximum fee based on staticFee and maxFee */
-function getLogicalMaxFee(ctxn) {
-	if (ctxn.type === "txn" || ctxn.type === "asyncTxn") return;
-	const maxFee = ctxn.data.maxFee;
-	const staticFee = ctxn.data.staticFee;
-	if (maxFee !== void 0 && (staticFee === void 0 || maxFee.microAlgos > staticFee.microAlgos)) return maxFee.microAlgos;
-	return staticFee?.microAlgos;
-}
+/** @deprecated Import from `@algorandfoundation/algokit-utils/composer` instead */
+const TransactionComposer = TransactionComposer$1;
 
 //#endregion
 export { TransactionComposer };