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

package/composer.js

@@ -0,0 +1,1584 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_constants = require('./packages/common/src/constants.js');
+const require_amount = require('./amount.js');
+const require_config = require('./config.js');
+const require_util = require('./util.js');
+const require_transaction = require('./transaction/transaction.js');
+const require_app_call = require('./packages/transact/src/transactions/app-call.js');
+const require_transaction_type = require('./packages/transact/src/transactions/transaction-type.js');
+const require_transaction$1 = require('./packages/transact/src/transactions/transaction.js');
+const require_signed_transaction = require('./packages/transact/src/transactions/signed-transaction.js');
+const require_signer = require('./packages/transact/src/signer.js');
+const require_app_manager = require('./app-manager.js');
+const require_app_call$1 = require('./transactions/app-call.js');
+const require_asset_transfer = require('./transactions/asset-transfer.js');
+const require_lifecycle_events = require('./lifecycle-events.js');
+const require_network_client = require('./network-client.js');
+const require_asset_config = require('./transactions/asset-config.js');
+const require_fee_coverage = require('./transactions/fee-coverage.js');
+const require_key_registration = require('./transactions/key-registration.js');
+const require_method_call = require('./transactions/method-call.js');
+const require_payment = require('./transactions/payment.js');
+let buffer = require("buffer");
+
+//#region src/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 require_app_manager.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 = require_transaction$1.decodeTransaction(require_transaction$1.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 = require_transaction$1.decodeTransaction(require_transaction$1.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 > require_constants.MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Adding ${txns.length} transaction(s) would exceed the maximum group size. Current: ${this.txns.length}, Maximum: ${require_constants.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");
+		require_transaction$1.validateTransaction(transaction);
+		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(),
+	*  rejectVersion: 1,
+	*  // 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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppUpdate(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: {
+				...params,
+				onComplete: require_app_call.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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppDelete(params) {
+		this.validateReferenceParams(params);
+		this.push({
+			data: {
+				...params,
+				onComplete: require_app_call.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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppCreateMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = require_method_call.extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: require_method_call.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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppUpdateMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = require_method_call.extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: require_method_call.processAppMethodCallArgs(params.args),
+				onComplete: require_app_call.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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppDeleteMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = require_method_call.extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: require_method_call.processAppMethodCallArgs(params.args),
+				onComplete: require_app_call.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(),
+	*  rejectVersion: 1,
+	*})
+	* ```
+	*/
+	addAppCallMethodCall(params) {
+		this.validateReferenceParams(params);
+		const txnArgs = require_method_call.extractComposerTransactionsFromAppMethodCallParams(params);
+		this.push(...txnArgs, {
+			data: {
+				...params,
+				args: require_method_call.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.map((txn) => new require_transaction$1.Transaction({ ...txn }));
+			const groupAnalysis = (this.composerConfig.coverAppCallInnerTransactionFees || this.composerConfig.populateAppCallResources) && builtTransactions.transactions.some((txn) => txn.type === require_transaction_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 && require_network_client.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") {
+			require_transaction$1.validateTransaction(ctxn.data.txn);
+			transactions.push(ctxn.data.txn);
+			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
+			transactionIndex++;
+		} else if (ctxn.type === "asyncTxn") {
+			const transaction = await ctxn.data.txn;
+			require_transaction$1.validateTransaction(transaction);
+			transactions.push(transaction);
+			if (ctxn.data.signer) signers.set(transactionIndex, ctxn.data.signer);
+			transactionIndex++;
+		} else {
+			let transaction;
+			switch (ctxn.type) {
+				case "pay":
+					transaction = require_payment.buildPayment(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetCreate":
+					transaction = require_asset_config.buildAssetCreate(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetConfig":
+					transaction = require_asset_config.buildAssetConfig(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetFreeze":
+					transaction = require_asset_config.buildAssetFreeze(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetDestroy":
+					transaction = require_asset_config.buildAssetDestroy(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetTransfer":
+					transaction = require_asset_transfer.buildAssetTransfer(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetOptIn":
+					transaction = require_asset_transfer.buildAssetOptIn(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "assetOptOut":
+					transaction = require_asset_transfer.buildAssetOptOut(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "appCall":
+					if (ctxn.data.appId === void 0 || ctxn.data.appId === 0) transaction = await require_app_call$1.buildAppCreate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await require_app_call$1.buildAppUpdate(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else transaction = require_app_call$1.buildAppCall(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "keyReg":
+					transaction = require_key_registration.buildKeyReg(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				case "methodCall":
+					if (ctxn.data.appId === void 0 || ctxn.data.appId === 0) transaction = await require_method_call.buildAppCreateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else if ("approvalProgram" in ctxn.data && "clearStateProgram" in ctxn.data) transaction = await require_method_call.buildAppUpdateMethodCall(ctxn.data, this.appManager, suggestedParams, defaultValidityWindow);
+					else transaction = await require_method_call.buildAppCallMethodCall(ctxn.data, suggestedParams, defaultValidityWindow);
+					break;
+				default: throw new Error(`Unsupported transaction type: ${ctxn.type}`);
+			}
+			if (transaction.fee === void 0) transaction = require_transaction$1.assignFee(transaction, {
+				feePerByte: suggestedParams.fee,
+				minFee: suggestedParams.minFee,
+				extraFee: ctxn.data.extraFee?.microAlgos,
+				maxFee: ctxn.data.maxFee?.microAlgos
+			});
+			require_transaction$1.validateTransaction(transaction);
+			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 > require_constants.MAX_TRANSACTION_GROUP_SIZE) throw new Error(`Transaction group size ${transactions.length} exceeds the maximum limit of ${require_constants.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 && require_fee_coverage.FeeDelta.isSurplus(txnAnalysis.requiredFeeDelta)) surplusGroupFees += require_fee_coverage.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 = require_fee_coverage.FeePriority.Covered;
+				if (txnAnalysis.requiredFeeDelta && require_fee_coverage.FeeDelta.isDeficit(txnAnalysis.requiredFeeDelta)) {
+					const deficitAmount = require_fee_coverage.FeeDelta.amount(txnAnalysis.requiredFeeDelta);
+					if (isImmutableFee || txn.type !== require_transaction_type.TransactionType.AppCall) priority = require_fee_coverage.FeePriority.ImmutableDeficit(deficitAmount);
+					else priority = require_fee_coverage.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 && require_fee_coverage.FeeDelta.isDeficit(requiredFeeDelta)) {
+					const deficitAmount = require_fee_coverage.FeeDelta.amount(requiredFeeDelta);
+					let additionalFeeDelta;
+					if (surplusGroupFees === 0n) additionalFeeDelta = requiredFeeDelta;
+					else if (surplusGroupFees >= deficitAmount) surplusGroupFees -= deficitAmount;
+					else {
+						additionalFeeDelta = require_fee_coverage.FeeDelta.fromBigInt(deficitAmount - surplusGroupFees);
+						surplusGroupFees = 0n;
+					}
+					if (additionalFeeDelta && require_fee_coverage.FeeDelta.isDeficit(additionalFeeDelta)) {
+						const additionalDeficitAmount = require_fee_coverage.FeeDelta.amount(additionalFeeDelta);
+						if (transactions[groupIndex].type === require_transaction_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 === require_transaction_type.TransactionType.AppCall) if (!(transactions[groupIndex].appCall?.accessReferences && transactions[groupIndex].appCall?.accessReferences?.length)) require_app_call$1.populateTransactionResources(transactions[groupIndex], unnamedResourcesAccessed, groupIndex);
+				else indexesWithAccessReferences.push(groupIndex);
+			}
+			if (indexesWithAccessReferences.length > 0) require_config.Config.logger.warn(`Resource population will be skipped for transaction indexes ${indexesWithAccessReferences.join(", ")} as they use access references.`);
+			if (groupAnalysis.unnamedResourcesAccessed) require_app_call$1.populateGroupResources(transactions, groupAnalysis.unnamedResourcesAccessed);
+		}
+		if (transactions.length > 1) {
+			const groupedTransactions = require_transaction$1.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 === require_transaction_type.TransactionType.AppCall) {
+				const logicalMaxFee = getLogicalMaxFee(ctxn);
+				if (logicalMaxFee !== void 0) params.fee = logicalMaxFee;
+				else appCallIndexesWithoutMaxFees.push(groupIndex);
+			}
+			return new require_transaction$1.Transaction(params);
+		});
+		if (transactionsToSimulate.length > 1) transactionsToSimulate = require_transaction$1.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: require_constants.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 = require_transaction$1.calculateFee(btxn, {
+					feePerByte: suggestedParams.fee,
+					minFee: suggestedParams.minFee
+				});
+				const txnFeeDelta = require_fee_coverage.FeeDelta.fromBigInt(minTxnFee - (btxn.fee ?? 0n));
+				if (btxn.type === require_transaction_type.TransactionType.AppCall) {
+					const innerTxnsFeeDelta = require_fee_coverage.calculateInnerFeeDelta(simulateTxnResult.txnResult.innerTxns, suggestedParams.minFee);
+					requiredFeeDelta = require_fee_coverage.FeeDelta.fromBigInt((innerTxnsFeeDelta ? require_fee_coverage.FeeDelta.toBigInt(innerTxnsFeeDelta) : 0n) + (txnFeeDelta ? require_fee_coverage.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.appId}-${a.name}`, `${b.appId}-${b.name}`);
+			});
+			sortedResources.appLocals?.sort((a, b) => {
+				return compare(`${a.appId}-${a.address}`, `${b.appId}-${b.address}`);
+			});
+			sortedResources.assetHoldings?.sort((a, b) => {
+				return compare(`${a.assetId}-${a.address}`, `${b.assetId}-${b.address}`);
+			});
+		}
+		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) {
+		const effectiveConfig = {
+			coverAppCallInnerTransactionFees: params?.coverAppCallInnerTransactionFees ?? this.composerConfig.coverAppCallInnerTransactionFees,
+			populateAppCallResources: params?.populateAppCallResources ?? this.composerConfig.populateAppCallResources
+		};
+		if (this.composerConfig.coverAppCallInnerTransactionFees !== effectiveConfig.coverAppCallInnerTransactionFees || this.composerConfig.populateAppCallResources !== effectiveConfig.populateAppCallResources) {
+			this.composerConfig = effectiveConfig;
+			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.Buffer.from(transactionsToSend[0].group).toString("base64") : "";
+				require_config.Config.getLogger(params?.suppressLog).verbose(`Sending group of ${transactionsToSend.length} transactions (${groupId})`, { transactionsToSend });
+				require_config.Config.getLogger(params?.suppressLog).debug(`Transaction IDs (${groupId})`, transactionIds);
+			}
+			if (require_config.Config.debug && require_config.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.transactionsWithSigners[0].txn.group;
+			let waitRounds = params?.maxRoundsToWaitForConfirmation;
+			if (waitRounds === void 0) {
+				const firstRound = (await this.getSuggestedParams()).firstValid;
+				const lastRound = this.transactionsWithSigners.reduce((max, txn) => txn.txn.lastValid > max ? txn.txn.lastValid : max, 0n);
+				waitRounds = Number(lastRound - firstRound) + 1;
+			}
+			await this.algod.sendRawTransaction(this.signedTransactions);
+			if (transactionsToSend.length > 1 && group) require_config.Config.getLogger(params?.suppressLog).verbose(`Group transaction (${buffer.Buffer.from(group).toString("base64")}) sent with ${transactionsToSend.length} transactions`);
+			else require_config.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 require_transaction.waitForConfirmation(id, waitRounds, this.algod)));
+			const abiReturns = this.parseAbiReturnValues(confirmations);
+			return {
+				groupId: group ? buffer.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 ? require_transaction$1.groupTransactions(this.rawBuildTransactions) : this.rawBuildTransactions;
+			if (require_config.Config.debug && typeof originalError === "object" && sentTransactions) {
+				err.traces = [];
+				require_config.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: require_signer.makeEmptyTransactionSigner()
+				}));
+				const signedTransactions = require_signed_transaction.decodeSignedTransactions(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 (require_config.Config.debug && !require_config.Config.traceAll) await require_config.Config.events.emitAsync(require_lifecycle_events.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 require_config.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 > 1 ? require_transaction$1.groupTransactions(builtTransactions.transactions) : builtTransactions.transactions).map((txn, index) => ({
+				txn,
+				signer: skipSignatures ? require_signer.makeEmptyTransactionSigner() : builtTransactions.signers.get(index) ?? require_signer.makeEmptyTransactionSigner()
+			}));
+		} else transactionsWithSigner = this.transactionsWithSigners.map((e) => ({
+			txn: e.txn,
+			signer: skipSignatures ? require_signer.makeEmptyTransactionSigner() : e.signer
+		}));
+		const transactions = transactionsWithSigner.map((e) => e.txn);
+		const simulateRequest = {
+			txnGroups: [{ txns: require_signed_transaction.decodeSignedTransactions(await this.signTransactions(transactionsWithSigner)) }],
+			...rawOptions,
+			...require_config.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 (require_config.Config.debug) await require_config.Config.events.emitAsync(require_lifecycle_events.EventType.TxnGroupSimulated, { simulateResponse });
+			throw await this.transformError(error);
+		}
+		if (require_config.Config.debug && require_config.Config.traceAll) await require_config.Config.events.emitAsync(require_lifecycle_events.EventType.TxnGroupSimulated, { 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.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 : require_util.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 encodedSignedTransactions = new Array(transactionsWithSigners.length).fill(null);
+		signerEntries.forEach(([, indexes], signerIndex) => {
+			const stxs = signedGroups[signerIndex];
+			indexes.forEach((txIndex, stxIndex) => {
+				encodedSignedTransactions[txIndex] = stxs[stxIndex] ?? null;
+			});
+		});
+		const unsignedIndexes = encodedSignedTransactions.map((stxn, index) => stxn == null ? index : null).filter((index) => index !== null);
+		if (unsignedIndexes.length > 0) throw new Error(`Transactions at indexes [${unsignedIndexes.join(", ")}] were not signed`);
+		return encodedSignedTransactions;
+	}
+	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 abiReturn = require_app_manager.AppManager.getABIReturn(confirmation, txn.data.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 require_amount.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;
+}
+
+//#endregion
+exports.TransactionComposer = TransactionComposer;
+//# sourceMappingURL=composer.js.map