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

package/types/algorand-client-transaction-sender.mjs

@@ -1,931 +1,8 @@
-import { getAddress, getApplicationAddress } from "../packages/common/src/address.mjs";
-import { Config } from "../config.mjs";
-import { asJson, defaultJsonValueReplacer } from "../util.mjs";
-import { AppManager } from "./app-manager.mjs";
-import { Buffer } from "buffer";
+import { AlgorandClientTransactionSender as AlgorandClientTransactionSender$1 } from "../algorand-client-transaction-sender.mjs";
 
 //#region src/types/algorand-client-transaction-sender.ts
-const getMethodCallForLog = ({ method, args }) => {
-	return `${method.name}(${(args ?? []).map((a) => typeof a === "object" ? asJson(a, (k, v) => {
-		const newV = defaultJsonValueReplacer(k, v);
-		return newV instanceof Uint8Array ? Buffer.from(newV).toString("base64") : newV;
-	}) : a)})`;
-};
-/** Orchestrates sending transactions for `AlgorandClient`. */
-var AlgorandClientTransactionSender = class {
-	_newGroup;
-	_assetManager;
-	_appManager;
-	/**
-	* Creates a new `AlgorandClientSender`
-	* @param newGroup A lambda that starts a new `TransactionComposer` transaction group
-	* @param assetManager An `AssetManager` instance
-	* @param appManager An `AppManager` instance
-	* @example
-	* ```typescript
-	* const transactionSender = new AlgorandClientTransactionSender(() => new TransactionComposer(), assetManager, appManager)
-	* ```
-	*/
-	constructor(newGroup, assetManager, appManager) {
-		this._newGroup = newGroup;
-		this._assetManager = assetManager;
-		this._appManager = appManager;
-	}
-	/**
-	* Start a new `TransactionComposer` transaction group
-	* @returns A new instance of `TransactionComposer`.
-	* @example
-	* const composer = AlgorandClient.mainNet().send.newGroup();
-	* const result = await composer.addTransaction(payment).send()
-	*/
-	newGroup() {
-		return this._newGroup();
-	}
-	_send(c, log) {
-		return async (params) => {
-			const composer = this._newGroup();
-			c(composer).apply(composer, [params]);
-			if (log?.preLog) {
-				const transaction = (await composer.build()).transactions.at(-1).txn;
-				Config.getLogger(params?.suppressLog).debug(log.preLog(params, transaction));
-			}
-			const rawResult = await composer.send(params);
-			const result = {
-				transaction: rawResult.transactions.at(-1),
-				confirmation: rawResult.confirmations.at(-1),
-				txId: rawResult.txIds.at(-1),
-				...rawResult
-			};
-			if (log?.postLog) Config.getLogger(params?.suppressLog).debug(log.postLog(params, result));
-			return result;
-		};
-	}
-	_sendAppCall(c, log) {
-		return async (params) => {
-			const result = await this._send(c, log)(params);
-			return {
-				...result,
-				return: AppManager.getABIReturn(result.confirmation, "method" in params ? params.method : void 0)
-			};
-		};
-	}
-	_sendAppUpdateCall(c, log) {
-		return async (params) => {
-			const result = await this._sendAppCall(c, log)(params);
-			const compiledApproval = typeof params.approvalProgram === "string" ? this._appManager.getCompilationResult(params.approvalProgram) : void 0;
-			const compiledClear = typeof params.clearStateProgram === "string" ? this._appManager.getCompilationResult(params.clearStateProgram) : void 0;
-			return {
-				...result,
-				compiledApproval,
-				compiledClear
-			};
-		};
-	}
-	_sendAppCreateCall(c, log) {
-		return async (params) => {
-			const result = await this._sendAppUpdateCall(c, log)(params);
-			return {
-				...result,
-				appId: BigInt(result.confirmation.appId),
-				appAddress: getApplicationAddress(result.confirmation.appId)
-			};
-		};
-	}
-	/**
-	* Send a payment transaction to transfer Algo between accounts.
-	* @param params The parameters for the payment transaction
-	* @example Basic example
-	* ```typescript
-	* const result = await algorand.send.payment({
-	*  sender: 'SENDERADDRESS',
-	*  receiver: 'RECEIVERADDRESS',
-	*  amount: (4).algo(),
-	* })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const result = await algorand.send.payment({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the payment transaction and the transaction that was sent
-	*/
-	payment = this._send((c) => c.addPayment, { preLog: (params, transaction) => `Sending ${params.amount.microAlgo} µALGO from ${params.sender} to ${params.receiver} via transaction ${transaction.txId()}` });
-	/**
-	* Create a new Algorand Standard Asset.
-	*
-	* The account that sends this transaction will automatically be
-	* opted in to the asset and will hold all units after creation.
-	*
-	* @param params The parameters for the asset creation transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetCreate({ sender: "CREATORADDRESS", total: 100n})
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetCreate({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset create transaction and the transaction that was sent
-	*/
-	assetCreate = async (params) => {
-		const result = await this._send((c) => c.addAssetCreate, { postLog: (params$1, result$1) => `Created asset${params$1.assetName ? ` ${params$1.assetName}` : ""}${params$1.unitName ? ` (${params$1.unitName})` : ""} with ${params$1.total} units and ${params$1.decimals ?? 0} decimals created by ${params$1.sender} with ID ${result$1.confirmation.assetId} via transaction ${result$1.txIds.at(-1)}` })(params);
-		return {
-			...result,
-			assetId: BigInt(result.confirmation.assetId ?? 0)
-		};
-	};
-	/**
-	* Configure an existing Algorand Standard Asset.
-	*
-	* **Note:** The manager, reserve, freeze, and clawback addresses
-	* are immutably empty if they are not set. If manager is not set then
-	* all fields are immutable from that point forward.
-	*
-	* @param params The parameters for the asset config transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetConfig({ sender: "MANAGERADDRESS", assetId: 123456n, manager: "MANAGERADDRESS" })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetConfig({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset config transaction and the transaction that was sent
-	*/
-	assetConfig = this._send((c) => c.addAssetConfig, { preLog: (params, transaction) => `Configuring asset with ID ${params.assetId} via transaction ${transaction.txId()}` });
-	/**
-	* Freeze or unfreeze an Algorand Standard Asset for an account.
-	*
-	* @param params The parameters for the asset freeze transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetFreeze({ sender: "MANAGERADDRESS", assetId: 123456n, account: "ACCOUNTADDRESS", frozen: true })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetFreeze({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset freeze transaction and the transaction that was sent
-	*/
-	assetFreeze = this._send((c) => c.addAssetFreeze, { preLog: (params, transaction) => `Freezing asset with ID ${params.assetId} via transaction ${transaction.txId()}` });
-	/**
-	* Destroys an Algorand Standard Asset.
-	*
-	* Created assets can be destroyed only by the asset manager account.
-	* All of the assets must be owned by the creator of the asset before
-	* the asset can be deleted.
-	*
-	* @param params The parameters for the asset destroy transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetDestroy({ sender: "MANAGERADDRESS", assetId: 123456n })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetDestroy({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset destroy transaction and the transaction that was sent
-	*/
-	assetDestroy = this._send((c) => c.addAssetDestroy, { preLog: (params, transaction) => `Destroying asset with ID ${params.assetId} via transaction ${transaction.txId()}` });
-	/**
-	* Transfer an Algorand Standard Asset.
-	*
-	* @param params The parameters for the asset transfer transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetTransfer({ sender: "HOLDERADDRESS", assetId: 123456n, amount: 1n, receiver: "RECEIVERADDRESS" })
-	* ```
-	* @example Advanced example (with clawback)
-	* ```typescript
-	* await algorand.send.assetTransfer({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset transfer transaction and the transaction that was sent
-	*/
-	assetTransfer = this._send((c) => c.addAssetTransfer, { preLog: (params, transaction) => `Transferring ${params.amount} units of asset with ID ${params.assetId} from ${params.sender} to ${params.receiver} via transaction ${transaction.txId()}` });
-	/**
-	* Opt an account into an Algorand Standard Asset.
-	*
-	* @param params The parameters for the asset opt-in transaction
-	*
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.assetOptIn({ sender: "SENDERADDRESS", assetId: 123456n })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetOptIn({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset opt-in transaction and the transaction that was sent
-	*/
-	assetOptIn = this._send((c) => c.addAssetOptIn, { preLog: (params, transaction) => `Opting in ${params.sender} to asset with ID ${params.assetId} via transaction ${transaction.txId()}` });
-	/**
-	* Opt an account out of an Algorand Standard Asset.
-	*
-	* *Note:* If the account has a balance of the asset,
-	* it will not be able to opt-out unless `ensureZeroBalance`
-	* is set to `false` (but then the account will lose the assets).
-	*
-	* @param params The parameters for the asset opt-out transaction
-	*
-	* @example Basic example (without creator, will be retrieved from algod)
-	* ```typescript
-	* await algorand.send.assetOptOut({ sender: "SENDERADDRESS", assetId: 123456n, ensureZeroBalance: true })
-	* ```
-	* @example Basic example (with creator)
-	* ```typescript
-	* await algorand.send.assetOptOut({ sender: "SENDERADDRESS", creator: "CREATORADDRESS", assetId: 123456n, ensureZeroBalance: true })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.assetOptOut({
-	*   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(),
-	*   // 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,
-	* })
-	* ```
-	* @returns The result of the asset opt-out transaction and the transaction that was sent
-	*/
-	assetOptOut = async (params) => {
-		if (params.ensureZeroBalance) {
-			let balance = 0n;
-			try {
-				balance = (await this._assetManager.getAccountInformation(getAddress(params.sender), params.assetId)).balance;
-			} catch {
-				throw new Error(`Account ${params.sender} is not opted-in to Asset ${params.assetId}; can't opt-out.`);
-			}
-			if (balance !== 0n) throw new Error(`Account ${params.sender} does not have a zero balance for Asset ${params.assetId}; can't opt-out.`);
-		}
-		params.creator = params.creator ?? (await this._assetManager.getById(params.assetId)).creator;
-		return await this._send((c) => c.addAssetOptOut, { preLog: (params$1, transaction) => `Opting ${params$1.sender} out of asset with ID ${params$1.assetId} to creator ${params$1.creator} via transaction ${transaction.txId()}` })(params);
-	};
-	/**
-	* Create a smart contract.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app creation transaction
-	* @example Basic example
-	* ```typescript
-	* const result = await algorand.send.appCreate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-	* const createdAppId = result.appId
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.appCreate({
-	*  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,
-	*})
-	* ```
-	* @returns The result of the app create transaction and the transaction that was sent
-	*/
-	appCreate = this._sendAppCreateCall((c) => c.addAppCreate, { postLog: (params, result) => `App created by ${params.sender} with ID ${result.confirmation.appId} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Update a smart contract.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app update transaction
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.appUpdate({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.appUpdate({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the app update transaction and the transaction that was sent
-	*/
-	appUpdate = this._sendAppUpdateCall((c) => c.addAppUpdate, { postLog: (params, result) => `App ${params.appId} updated ${params.args ? ` with ${params.args.map((a) => Buffer.from(a).toString("base64"))}` : ""} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Delete a smart contract.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app deletion transaction
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.appDelete({ sender: 'CREATORADDRESS' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.appDelete({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the app delete transaction and the transaction that was sent
-	*/
-	appDelete = this._sendAppCall((c) => c.addAppDelete, { postLog: (params, result) => `App ${params.appId} deleted ${params.args ? ` with ${params.args.map((a) => Buffer.from(a).toString("base64"))}` : ""} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Call a smart contract.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app call transaction
-	* @example Basic example
-	* ```typescript
-	* await algorand.send.appCall({ sender: 'CREATORADDRESS' })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* await algorand.send.appCall({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the app call transaction and the transaction that was sent
-	*/
-	appCall = this._sendAppCall((c) => c.addAppCall, { postLog: (params, result) => `App ${params.appId} called ${params.args ? ` with ${params.args.map((a) => Buffer.from(a).toString("base64"))}` : ""} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Create a smart contract via an ABI method.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app creation transaction
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* const result = await algorand.send.appCreateMethodCall({ sender: 'CREATORADDRESS', approvalProgram: 'TEALCODE', clearStateProgram: 'TEALCODE', method: method, args: ["arg1_value"] })
-	* const createdAppId = result.appId
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* await algorand.send.appCreateMethodCall({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the application ABI method create transaction and the transaction that was sent
-	*/
-	appCreateMethodCall = this._sendAppCreateCall((c) => c.addAppCreateMethodCall, { postLog: (params, result) => `App created by ${params.sender} with ID ${result.confirmation.appId} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Update a smart contract via an ABI method.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app update transaction
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* await algorand.send.appUpdateMethodCall({ 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' },
-	* })
-	* await algorand.send.appUpdateMethodCall({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the application ABI method update transaction and the transaction that was sent
-	*/
-	appUpdateMethodCall = this._sendAppUpdateCall((c) => c.addAppUpdateMethodCall, { postLog: (params, result) => `App ${params.appId} updated with ${getMethodCallForLog(params)} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Delete a smart contract via an ABI method.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app deletion transaction
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* await algorand.send.appDeleteMethodCall({ 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' },
-	* })
-	* await algorand.send.appDeleteMethodCall({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the application ABI method delete transaction and the transaction that was sent
-	*/
-	appDeleteMethodCall = this._sendAppCall((c) => c.addAppDeleteMethodCall, { postLog: (params, result) => `App ${params.appId} deleted with ${getMethodCallForLog(params)} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Call a smart contract via an ABI method.
-	*
-	* Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
-	*
-	* @param params The parameters for the app call transaction
-	* @example Basic example
-	* ```typescript
-	* const method = new ABIMethod({
-	*   name: 'method',
-	*   args: [{ name: 'arg1', type: 'string' }],
-	*   returns: { type: 'string' },
-	* })
-	* await algorand.send.appCallMethodCall({ 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' },
-	* })
-	* await algorand.send.appCallMethodCall({
-	*  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,
-	*  // 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,
-	*})
-	* ```
-	* @returns The result of the application ABI method call transaction and the transaction that was sent
-	*/
-	appCallMethodCall = this._sendAppCall((c) => c.addAppCallMethodCall, { postLog: (params, result) => `App ${params.appId} called with ${getMethodCallForLog(params)} by ${params.sender} via transaction ${result.txIds.at(-1)}` });
-	/**
-	* Register an online key.
-	* @param params The parameters for the key registration transaction
-	* @example Basic example
-	* ```typescript
-	* const result = await algorand.send.onlineKeyRegistration({
-	*   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
-	* const result = await algorand.send.onlineKeyRegistration({
-	*   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(),
-	* })
-	* ```
-	* @returns The result of the online key registration transaction and the transaction that was sent
-	*/
-	onlineKeyRegistration = this._send((c) => c.addOnlineKeyRegistration, { preLog: (params, transaction) => `Registering online key for ${params.sender} via transaction ${transaction.txId()}` });
-	/**
-	* Register an offline key.
-	* @param params The parameters for the key registration transaction
-	* @example Basic example
-	* ```typescript
-	* const result = await algorand.send.offlineKeyRegistration({
-	*   sender: 'SENDERADDRESS',
-	* })
-	* ```
-	* @example Advanced example
-	* ```typescript
-	* const result = await algorand.send.offlineKeyRegistration({
-	*   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(),
-	* })
-	* ```
-	* @returns The result of the offline key registration transaction and the transaction that was sent
-	*/
-	offlineKeyRegistration = this._send((c) => c.addOfflineKeyRegistration, { preLog: (params, transaction) => `Registering offline key for ${params.sender} via transaction ${transaction.txId()}` });
-};
+/** @deprecated Import from `@algorandfoundation/algokit-utils/algorand-client-transaction-sender` instead */
+const AlgorandClientTransactionSender = AlgorandClientTransactionSender$1;
 
 //#endregion
 export { AlgorandClientTransactionSender };