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

package/types/app-client.js

@@ -1,909 +1,8 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
-const require_address = require('../packages/common/src/address.js');
-const require_app_call = require('../packages/transact/src/transactions/app-call.js');
-const require_sourcemap = require('../packages/sdk/src/logic/sourcemap.js');
-const require_config = require('../config.js');
-const require_util = require('../util.js');
-const require_abi_method = require('../packages/abi/src/abi-method.js');
-const require_arc56_contract = require('../packages/abi/src/arc56-contract.js');
-const require_lifecycle_events = require('./lifecycle-events.js');
-const require_app_spec = require('./app-spec.js');
-const require_logic_error = require('./logic-error.js');
-let buffer = require("buffer");
-buffer = require_rolldown_runtime.__toESM(buffer);
+const require_app_client = require('../app-client.js');
 
 //#region src/types/app-client.ts
-/** The maximum opcode budget for a simulate call as per https://github.com/algorand/go-algorand/blob/807b29a91c371d225e12b9287c5d56e9b33c4e4c/ledger/simulation/trace.go#L104 */
-const MAX_SIMULATE_OPCODE_BUDGET = 2e4 * 16;
-const BYTE_CBLOCK = 38;
-const INT_CBLOCK = 32;
-/**
-* Get the offset of the last constant block at the beginning of the program
-* This value is used to calculate the program counter for an ARC56 program that has a pcOffsetMethod of "cblocks"
-*
-* @param program The program to parse
-* @returns The PC value of the opcode after the last constant block
-*/
-function getConstantBlockOffset(program) {
-	const bytes = [...program];
-	const programSize = bytes.length;
-	bytes.shift();
-	/** The PC of the opcode after the bytecblock */
-	let bytecblockOffset;
-	/** The PC of the opcode after the intcblock */
-	let intcblockOffset;
-	while (bytes.length > 0) {
-		/** The current byte from the beginning of the byte array */
-		const byte = bytes.shift();
-		if (byte === BYTE_CBLOCK || byte === INT_CBLOCK) {
-			const isBytecblock = byte === BYTE_CBLOCK;
-			/** The byte following the opcode is the number of values in the constant block */
-			const valuesRemaining = bytes.shift();
-			for (let i = 0; i < valuesRemaining; i++) if (isBytecblock) {
-				/** The byte following the opcode is the length of the next element */
-				const length = bytes.shift();
-				bytes.splice(0, length);
-			} else while ((bytes.shift() & 128) !== 0);
-			if (isBytecblock) bytecblockOffset = programSize - bytes.length - 1;
-			else intcblockOffset = programSize - bytes.length - 1;
-			if (bytes[0] !== BYTE_CBLOCK && bytes[0] !== INT_CBLOCK) break;
-		}
-	}
-	return Math.max(bytecblockOffset ?? 0, intcblockOffset ?? 0);
-}
-/** ARC-56/ARC-32 application client that allows you to manage calls and
-* state for a specific deployed instance of an app (with a known app ID). */
-var AppClient = class AppClient {
-	_appId;
-	_appAddress;
-	_appName;
-	_appSpec;
-	_algorand;
-	_defaultSender;
-	_defaultSigner;
-	_approvalSourceMap;
-	_clearSourceMap;
-	_localStateMethods;
-	_globalStateMethods;
-	_boxStateMethods;
-	_paramsMethods;
-	_createTransactionsMethods;
-	_sendMethods;
-	_lastCompiled;
-	/**
-	* Create a new app client.
-	* @param params The parameters to create the app client
-	* @returns The `AppClient` instance
-	* @example
-	* ```typescript
-	* const appClient = new AppClient({
-	*   appId: 12345678n,
-	*   appSpec: appSpec,
-	*   algorand: AlgorandClient.mainNet(),
-	* })
-	*/
-	constructor(params) {
-		this._appId = params.appId;
-		this._appAddress = require_address.getApplicationAddress(this._appId);
-		this._appSpec = AppClient.normaliseAppSpec(params.appSpec);
-		this._appName = params.appName ?? this._appSpec.name;
-		this._algorand = params.algorand;
-		this._algorand.registerErrorTransformer(this.handleCallErrors);
-		this._defaultSender = require_address.getOptionalAddress(params.defaultSender);
-		this._defaultSigner = params.defaultSigner;
-		this._lastCompiled = {};
-		this._approvalSourceMap = params.approvalSourceMap;
-		this._clearSourceMap = params.clearSourceMap;
-		this._localStateMethods = (address) => this.getStateMethods(() => this.getLocalState(address), () => require_arc56_contract.getLocalABIStorageKeys(this._appSpec), () => require_arc56_contract.getLocalABIStorageMaps(this._appSpec));
-		this._globalStateMethods = this.getStateMethods(() => this.getGlobalState(), () => require_arc56_contract.getGlobalABIStorageKeys(this._appSpec), () => require_arc56_contract.getGlobalABIStorageMaps(this._appSpec));
-		this._boxStateMethods = this.getBoxMethods();
-		this._paramsMethods = {
-			...this.getMethodCallParamsMethods(),
-			bare: this.getBareParamsMethods()
-		};
-		this._createTransactionsMethods = {
-			...this.getMethodCallCreateTransactionMethods(),
-			bare: this.getBareCreateTransactionMethods()
-		};
-		this._sendMethods = {
-			...this.getMethodCallSendMethods(),
-			bare: this.getBareSendMethods()
-		};
-	}
-	/**
-	* Clone this app client with different params
-	*
-	* @param params The params to use for the the cloned app client. Omit a param to keep the original value. Set a param to override the original value. Setting to undefined will clear the original value.
-	* @returns A new app client with the altered params
-	* @example
-	* ```typescript
-	* const appClient2 = appClient.clone({ defaultSender: 'NEW_SENDER_ADDRESS' })
-	* ```
-	*/
-	clone(params) {
-		return new AppClient({
-			appId: this._appId,
-			appSpec: this._appSpec,
-			algorand: this._algorand,
-			appName: this._appName,
-			defaultSender: this._defaultSender,
-			defaultSigner: this._defaultSigner,
-			approvalSourceMap: this._approvalSourceMap,
-			clearSourceMap: this._clearSourceMap,
-			...params
-		});
-	}
-	/**
-	* Returns a new `AppClient` client, resolving the app by creator address and name
-	* using AlgoKit app deployment semantics (i.e. looking for the app creation transaction note).
-	* @param params The parameters to create the app client
-	* @returns The `AppClient` instance
-	* @example
-	* ```typescript
-	* const appClient = await AppClient.fromCreatorAndName({
-	*   creatorAddress: 'CREATOR_ADDRESS',
-	*   name: 'APP_NAME',
-	*   appSpec: appSpec,
-	*   algorand: AlgorandClient.mainNet(),
-	* })
-	*/
-	static async fromCreatorAndName(params) {
-		const appSpec = AppClient.normaliseAppSpec(params.appSpec);
-		const appMetadata = (params.appLookupCache ?? await params.algorand.appDeployer.getCreatorAppsByName(params.creatorAddress, params.ignoreCache)).apps[params.appName ?? appSpec.name];
-		if (!appMetadata) throw new Error(`App not found for creator ${params.creatorAddress} and name ${params.appName ?? appSpec.name}`);
-		return new AppClient({
-			...params,
-			algorand: params.algorand,
-			appId: appMetadata.appId
-		});
-	}
-	/**
-	* Returns an `AppClient` instance for the current network based on
-	* pre-determined network-specific app IDs specified in the ARC-56 app spec.
-	*
-	* If no IDs are in the app spec or the network isn't recognised, an error is thrown.
-	* @param params The parameters to create the app client
-	* @returns The `AppClient` instance
-	* @example
-	* ```typescript
-	* const appClient = await AppClient.fromNetwork({
-	*   appSpec: appSpec,
-	*   algorand: AlgorandClient.mainNet(),
-	* })
-	*/
-	static async fromNetwork(params) {
-		const network = await params.algorand.client.network();
-		const appSpec = AppClient.normaliseAppSpec(params.appSpec);
-		const networkNames = [network.genesisHash];
-		if (network.isLocalNet) networkNames.push("localnet");
-		if (network.isTestNet) networkNames.push("testnet");
-		if (network.isMainNet) networkNames.push("mainnet");
-		const networkIndex = Object.keys(appSpec.networks ?? {}).findIndex((n) => networkNames.includes(n));
-		if (networkIndex === -1) throw new Error(`No app ID found for network ${require_util.asJson(networkNames)} in the app spec`);
-		const appId = BigInt(appSpec.networks[networkIndex].appID);
-		return new AppClient({
-			...params,
-			appId,
-			appSpec
-		});
-	}
-	/**
-	* Takes a string or parsed JSON object that could be ARC-32 or ARC-56 format and
-	* normalises it into a parsed ARC-56 contract object.
-	* @param spec The spec to normalise
-	* @returns The normalised ARC-56 contract object
-	* @example
-	* ```typescript
-	* const arc56AppSpec = AppClient.normaliseAppSpec(appSpec)
-	* ```
-	*/
-	static normaliseAppSpec(spec) {
-		const parsedSpec = typeof spec === "string" ? JSON.parse(spec) : spec;
-		return "hints" in parsedSpec ? require_app_spec.arc32ToArc56(parsedSpec) : parsedSpec;
-	}
-	/** The ID of the app instance this client is linked to. */
-	get appId() {
-		return this._appId;
-	}
-	/** The app address of the app instance this client is linked to. */
-	get appAddress() {
-		return this._appAddress;
-	}
-	/** The name of the app (from the ARC-32 / ARC-56 app spec or override). */
-	get appName() {
-		return this._appName;
-	}
-	/** The ARC-56 app spec being used */
-	get appSpec() {
-		return this._appSpec;
-	}
-	/** A reference to the underlying `AlgorandClient` this app client is using. */
-	get algorand() {
-		return this._algorand;
-	}
-	/** Get parameters to create transactions for the current app.
-	*
-	* A good mental model for this is that these parameters represent a deferred transaction creation.
-	* @example Create a transaction in the future using Algorand Client
-	* ```typescript
-	* const myMethodCall = appClient.params.call({method: 'my_method', args: [123, 'hello']})
-	* // ...
-	* await algorand.send.AppMethodCall(myMethodCall)
-	* ```
-	* @example Define a nested transaction as an ABI argument
-	* ```typescript
-	* const myMethodCall = appClient.params.call({method: 'my_method', args: [123, 'hello']})
-	* await appClient.send.call({method: 'my_method2', args: [myMethodCall]})
-	* ```
-	*/
-	get params() {
-		return this._paramsMethods;
-	}
-	/** Create transactions for the current app */
-	get createTransaction() {
-		return this._createTransactionsMethods;
-	}
-	/** Send transactions to the current app */
-	get send() {
-		return this._sendMethods;
-	}
-	/** Get state (local, global, box) from the current app */
-	get state() {
-		return {
-			local: this._localStateMethods,
-			global: this._globalStateMethods,
-			box: this._boxStateMethods
-		};
-	}
-	/**
-	* Funds Algo into the app account for this app.
-	*
-	* An alias for `appClient.send.fundAppAccount(params)`.
-	* @param params The parameters for the funding transaction
-	* @returns The result of the funding
-	* @example
-	* ```typescript
-	* await appClient.fundAppAccount({ amount: algo(1) })
-	* ```
-	*/
-	async fundAppAccount(params) {
-		return this.send.fundAppAccount(params);
-	}
-	/**
-	* Returns raw global state for the current app.
-	* @returns The global state
-	* @example
-	* ```typescript
-	* const globalState = await appClient.getGlobalState()
-	* ```
-	*/
-	async getGlobalState() {
-		return await this._algorand.app.getGlobalState(this.appId);
-	}
-	/**
-	* Returns raw local state for the given account address.
-	* @param address The address of the account to get the local state for
-	* @returns The local state
-	* @example
-	* ```typescript
-	* const localState = await appClient.getLocalState('ACCOUNT_ADDRESS')
-	* ```
-	*/
-	async getLocalState(address) {
-		return await this._algorand.app.getLocalState(this.appId, require_address.getAddress(address));
-	}
-	/**
-	* Returns the names of all current boxes for the current app.
-	* @returns The names of the boxes
-	* @example
-	* ```typescript
-	* const boxNames = await appClient.getBoxNames()
-	* ```
-	*/
-	async getBoxNames() {
-		return await this._algorand.app.getBoxNames(this.appId);
-	}
-	/**
-	* Returns the value of the given box for the current app.
-	* @param name The identifier of the box to return
-	* @returns The current box value as a byte array
-	* @example
-	* ```typescript
-	* const boxValue = await appClient.getBoxValue('boxName')
-	* ```
-	*/
-	async getBoxValue(name) {
-		return await this._algorand.app.getBoxValue(this.appId, name);
-	}
-	/**
-	* Returns the value of the given box for the current app.
-	* @param name The identifier of the box to return
-	* @param type
-	* @returns The current box value as a byte array
-	* @example
-	* ```typescript
-	* const boxValue = await appClient.getBoxValueFromABIType('boxName', new ABIUintType(32))
-	* ```
-	*/
-	async getBoxValueFromABIType(name, type) {
-		return await this._algorand.app.getBoxValueFromABIType({
-			appId: this.appId,
-			boxName: name,
-			type
-		});
-	}
-	/**
-	* Returns the values of all current boxes for the current app.
-	* Note: This will issue multiple HTTP requests (one per box) and it's not an atomic operation so values may be out of sync.
-	* @param filter Optional filter to filter which boxes' values are returned
-	* @returns The (name, value) pair of the boxes with values as raw byte arrays
-	* @example
-	* ```typescript
-	* const boxValues = await appClient.getBoxValues()
-	* ```
-	*/
-	async getBoxValues(filter) {
-		const names = (await this.getBoxNames()).filter(filter ?? ((_) => true));
-		const values = await this._algorand.app.getBoxValues(this.appId, names.map((name) => name.nameRaw));
-		return names.map((name, i) => ({
-			name,
-			value: values[i]
-		}));
-	}
-	/**
-	* Returns the values of all current boxes for the current app decoded using an ABI Type.
-	* Note: This will issue multiple HTTP requests (one per box) and it's not an atomic operation so values may be out of sync.
-	* @param type The ABI type to decode the values with
-	* @param filter Optional filter to filter which boxes' values are returned
-	* @returns The (name, value) pair of the boxes with values as the ABI Value
-	* @example
-	* ```typescript
-	* const boxValues = await appClient.getBoxValuesFromABIType(new ABIUintType(32))
-	* ```
-	*/
-	async getBoxValuesFromABIType(type, filter) {
-		const names = (await this.getBoxNames()).filter(filter ?? ((_) => true));
-		const values = await this._algorand.app.getBoxValuesFromABIType({
-			appId: this.appId,
-			boxNames: names.map((name) => name.nameRaw),
-			type
-		});
-		return names.map((name, i) => ({
-			name,
-			value: values[i]
-		}));
-	}
-	/**
-	* Takes an error that may include a logic error from a call to the current app and re-exposes the
-	* error to include source code information via the source map and ARC-56 spec.
-	* @param e The error to parse
-	* @param isClearStateProgram Whether or not the code was running the clear state program (defaults to approval program)
-	* @returns The new error, or if there was no logic error or source map then the wrapped error with source details
-	*/
-	async exposeLogicError(e, isClearStateProgram) {
-		const pcOffsetMethod = this._appSpec.sourceInfo?.[isClearStateProgram ? "clear" : "approval"]?.pcOffsetMethod;
-		let program;
-		if (pcOffsetMethod === "cblocks") {
-			const appInfo = await this._algorand.app.getById(this.appId);
-			program = isClearStateProgram ? appInfo.clearStateProgram : appInfo.approvalProgram;
-		}
-		return AppClient.exposeLogicError(e, this._appSpec, {
-			isClearStateProgram,
-			approvalSourceMap: this._approvalSourceMap,
-			clearSourceMap: this._clearSourceMap,
-			program
-		});
-	}
-	/**
-	* Export the current source maps for the app.
-	* @returns The source maps
-	*/
-	exportSourceMaps() {
-		if (!this._approvalSourceMap || !this._clearSourceMap) throw new Error("Unable to export source maps; they haven't been loaded into this client - you need to call create, update, or deploy first");
-		return {
-			approvalSourceMap: this._approvalSourceMap,
-			clearSourceMap: this._clearSourceMap
-		};
-	}
-	/**
-	* Import source maps for the app.
-	* @param sourceMaps The source maps to import
-	*/
-	importSourceMaps(sourceMaps) {
-		this._approvalSourceMap = new require_sourcemap.ProgramSourceMap(sourceMaps.approvalSourceMap);
-		this._clearSourceMap = new require_sourcemap.ProgramSourceMap(sourceMaps.clearSourceMap);
-	}
-	/**
-	* Returns the ABI Method spec for the given method string for the app represented by this application client instance
-	* @param methodNameOrSignature The method name or method signature to call if an ABI call is being emitted.
-	* e.g. `my_method` or `my_method(unit64,string)bytes`
-	* @returns A tuple with: [ARC-56 `Method`, algosdk `ABIMethod`]
-	*/
-	getABIMethod(methodNameOrSignature) {
-		return require_abi_method.getABIMethod(methodNameOrSignature, this._appSpec);
-	}
-	/**
-	* Checks for decode errors on the SendAppTransactionResult and maps the return value to the specified type
-	* on the ARC-56 method, replacing the `return` property with the decoded type.
-	*
-	* If the return type is an ARC-56 struct then the struct will be returned.
-	*
-	* @param result The SendAppTransactionResult to be mapped
-	* @param method The method that was called
-	* @returns The smart contract response with an updated return value
-	*/
-	async processMethodCallReturn(result) {
-		const resultValue = await result;
-		return {
-			...resultValue,
-			return: resultValue.return?.returnValue
-		};
-	}
-	/**
-	* Compiles the approval and clear state programs (if TEAL templates provided),
-	* performing any provided deploy-time parameter replacement and stores
-	* the source maps.
-	*
-	* If no TEAL templates provided it will use any byte code provided in the app spec.
-	*
-	* Will store any generated source maps for later use in debugging.
-	* @param compilation Any compilation parameters to use
-	* @returns The compiled code and any compilation results (including source maps)
-	*/
-	async compile(compilation) {
-		const result = await AppClient.compile(this._appSpec, this._algorand.app, compilation);
-		if (result.compiledApproval) {
-			this._approvalSourceMap = result.compiledApproval.sourceMap;
-			this._lastCompiled.approval = result.compiledApproval.compiledBase64ToBytes;
-		}
-		if (result.compiledClear) {
-			this._clearSourceMap = result.compiledClear.sourceMap;
-			this._lastCompiled.clear = result.compiledClear.compiledBase64ToBytes;
-		}
-		return result;
-	}
-	/**
-	* Takes an error that may include a logic error from a call to the current app and re-exposes the
-	* error to include source code information via the source map and ARC-56 spec.
-	* @param e The error to parse
-	* @param appSpec The app spec for the app
-	* @param details Additional information to inform the error
-	* @returns The new error, or if there was no logic error or source map then the wrapped error with source details
-	*/
-	static exposeLogicError(e, appSpec, details) {
-		const { isClearStateProgram, approvalSourceMap, clearSourceMap, program } = details;
-		const sourceMap = isClearStateProgram ? clearSourceMap : approvalSourceMap;
-		const errorDetails = require_logic_error.LogicError.parseLogicError(e);
-		if (errorDetails === void 0 || errorDetails?.pc === void 0) return e;
-		/** The PC value to find in the ARC56 SourceInfo */
-		let arc56Pc = errorDetails?.pc;
-		const programSourceInfo = isClearStateProgram ? appSpec.sourceInfo?.clear : appSpec.sourceInfo?.approval;
-		/** The offset to apply to the PC if using the cblocks pc offset method */
-		let cblocksOffset = 0;
-		if (programSourceInfo?.pcOffsetMethod === "cblocks") {
-			if (program === void 0) throw new Error("Program bytes are required to calculate the ARC56 cblocks PC offset");
-			cblocksOffset = getConstantBlockOffset(program);
-			arc56Pc = errorDetails.pc - cblocksOffset;
-		}
-		const errorMessage = (programSourceInfo?.sourceInfo.find((s) => s.pc.includes(arc56Pc)))?.errorMessage;
-		if (appSpec.source) {
-			let getLineForPc = (inputPc) => sourceMap?.getLocationForPc?.(inputPc)?.line;
-			if (sourceMap === void 0) getLineForPc = (inputPc) => {
-				const teal = programSourceInfo?.sourceInfo.find((s) => s.pc.includes(inputPc - cblocksOffset))?.teal;
-				if (teal === void 0) return void 0;
-				return teal - 1;
-			};
-			e = new require_logic_error.LogicError(errorDetails, buffer.Buffer.from(isClearStateProgram ? appSpec.source.clear : appSpec.source.approval, "base64").toString().split("\n"), getLineForPc);
-		}
-		if (errorMessage) {
-			const appId = require_util.asJson(e).match(/(?<=app=)\d+/)?.[0] || "";
-			const txId = require_util.asJson(e).match(/(?<=transaction )\S+(?=:)/)?.[0];
-			const error = /* @__PURE__ */ new Error(`Runtime error when executing ${appSpec.name} (appId: ${appId}) in transaction ${txId}: ${errorMessage}`);
-			error.cause = e;
-			return error;
-		}
-		return e;
-	}
-	/**
-	* Compiles the approval and clear state programs (if TEAL templates provided),
-	* performing any provided deploy-time parameter replacement and returns
-	* the compiled code and any compilation results (including source maps).
-	*
-	* If no TEAL templates provided it will use any byte code provided in the app spec.
-	*
-	* Will store any generated source maps for later use in debugging.
-	* @param appSpec The app spec for the app
-	* @param appManager The app manager to use for compilation
-	* @param compilation Any compilation parameters to use
-	* @returns The compiled code and any compilation results (including source maps)
-	*/
-	static async compile(appSpec, appManager, compilation) {
-		const { deployTimeParams, updatable, deletable } = compilation ?? {};
-		if (!appSpec.source) {
-			if (!appSpec.byteCode?.approval || !appSpec.byteCode?.clear) throw new Error(`Attempt to compile app ${appSpec.name} without source or byteCode`);
-			return {
-				approvalProgram: buffer.Buffer.from(appSpec.byteCode.approval, "base64"),
-				clearStateProgram: buffer.Buffer.from(appSpec.byteCode.clear, "base64")
-			};
-		}
-		const approvalTemplate = buffer.Buffer.from(appSpec.source.approval, "base64").toString("utf-8");
-		const compiledApproval = await appManager.compileTealTemplate(approvalTemplate, deployTimeParams, {
-			updatable,
-			deletable
-		});
-		const clearTemplate = buffer.Buffer.from(appSpec.source.clear, "base64").toString("utf-8");
-		const compiledClear = await appManager.compileTealTemplate(clearTemplate, deployTimeParams);
-		if (require_config.Config.debug) await require_config.Config.events.emitAsync(require_lifecycle_events.EventType.AppCompiled, { sources: [{
-			compiledTeal: compiledApproval,
-			appName: appSpec.name,
-			fileName: "approval"
-		}, {
-			compiledTeal: compiledClear,
-			appName: appSpec.name,
-			fileName: "clear"
-		}] });
-		return {
-			approvalProgram: compiledApproval.compiledBase64ToBytes,
-			compiledApproval,
-			clearStateProgram: compiledClear.compiledBase64ToBytes,
-			compiledClear
-		};
-	}
-	/**
-	* Returns ABI method arguments ready for a method call params object with default values populated
-	* and structs replaced with tuples.
-	*
-	* It does this by replacing any `undefined` values with the equivalent default value from the given ARC-56 app spec.
-	* @param methodNameOrSignature The method name or method signature to call if an ABI call is being emitted.
-	* e.g. `my_method` or `my_method(unit64,string)bytes`
-	* @param args The arguments to the method with `undefined` for any that should be populated with a default value
-	*/
-	async getABIArgsWithDefaultValues(methodNameOrSignature, args, sender) {
-		const m = require_abi_method.getABIMethod(methodNameOrSignature, this._appSpec);
-		return await Promise.all(args?.map(async (arg, i) => {
-			const methodArg = m.args[i];
-			if (!methodArg) throw new Error(`Unexpected arg at position ${i}. ${m.name} only expects ${m.args.length} args`);
-			if (require_abi_method.argTypeIsTransaction(methodArg.type)) return arg;
-			if (arg !== void 0) return arg;
-			const defaultValue = methodArg.defaultValue;
-			if (defaultValue) switch (defaultValue.source) {
-				case "literal": {
-					const bytes = buffer.Buffer.from(defaultValue.data, "base64");
-					return require_abi_method.getABIDecodedValue(defaultValue.type ?? methodArg.type, bytes);
-				}
-				case "method": {
-					const method = this.getABIMethod(defaultValue.data);
-					const result = await this.send.call({
-						method: defaultValue.data,
-						args: method.args.map(() => void 0),
-						sender
-					});
-					if (result.return === void 0) throw new Error("Default value method call did not return a value");
-					return result.return;
-				}
-				case "local":
-				case "global":
-				case "box": return await this.getDefaultValueFromStorage({
-					data: defaultValue.data,
-					source: defaultValue.source
-				}, methodArg.name ?? `arg${i + 1}`, sender);
-			}
-		}) ?? []);
-	}
-	async getDefaultValueFromStorage(defaultValue, argName, sender) {
-		const keys = defaultValue.source === "box" ? require_arc56_contract.getBoxABIStorageKeys(this.appSpec) : defaultValue.source === "global" ? require_arc56_contract.getGlobalABIStorageKeys(this.appSpec) : require_arc56_contract.getLocalABIStorageKeys(this.appSpec);
-		const key = Object.values(keys).find((s) => s.key === defaultValue.data);
-		if (!key) throw new Error(`Unable to find default value for argument '${argName}': The storage key (base64: '${defaultValue.data}') is not defined in the contract's ${defaultValue.source} storage schema`);
-		if (defaultValue.source === "box") {
-			const value$1 = await this.getBoxValue(buffer.Buffer.from(defaultValue.data, "base64"));
-			return require_abi_method.getABIDecodedValue(key.valueType, value$1);
-		}
-		const state = defaultValue.source === "global" ? await this.getGlobalState() : await this.getLocalState(sender);
-		const value = Object.values(state).find((s) => s.keyBase64 === defaultValue.data);
-		if (!value) throw new Error(`Unable to find default value for argument '${argName}': No value exists in ${defaultValue.source} storage for key (base64: '${defaultValue.data}')`);
-		return "valueRaw" in value ? require_abi_method.getABIDecodedValue(key.valueType, value.valueRaw) : value.value;
-	}
-	getBareParamsMethods() {
-		return {
-			update: async (params) => {
-				return this.getBareParams({
-					...params,
-					...await this.compile(params)
-				}, require_app_call.OnApplicationComplete.UpdateApplication);
-			},
-			optIn: (params) => {
-				return this.getBareParams(params, require_app_call.OnApplicationComplete.OptIn);
-			},
-			delete: (params) => {
-				return this.getBareParams(params, require_app_call.OnApplicationComplete.DeleteApplication);
-			},
-			clearState: (params) => {
-				return this.getBareParams(params, require_app_call.OnApplicationComplete.ClearState);
-			},
-			closeOut: (params) => {
-				return this.getBareParams(params, require_app_call.OnApplicationComplete.CloseOut);
-			},
-			call: (params) => {
-				return this.getBareParams(params, params?.onComplete ?? require_app_call.OnApplicationComplete.NoOp);
-			}
-		};
-	}
-	getBareCreateTransactionMethods() {
-		return {
-			update: async (params) => {
-				return this._algorand.createTransaction.appUpdate(await this.params.bare.update(params));
-			},
-			optIn: (params) => {
-				return this._algorand.createTransaction.appCall(this.params.bare.optIn(params));
-			},
-			delete: (params) => {
-				return this._algorand.createTransaction.appDelete(this.params.bare.delete(params));
-			},
-			clearState: (params) => {
-				return this._algorand.createTransaction.appCall(this.params.bare.clearState(params));
-			},
-			closeOut: (params) => {
-				return this._algorand.createTransaction.appCall(this.params.bare.closeOut(params));
-			},
-			call: (params) => {
-				return this._algorand.createTransaction.appCall(this.params.bare.call(params));
-			}
-		};
-	}
-	getBareSendMethods() {
-		return {
-			update: async (params) => {
-				const compiled = await this.compile(params);
-				return {
-					...await this._algorand.send.appUpdate(await this.params.bare.update(params)),
-					...compiled
-				};
-			},
-			optIn: (params) => {
-				return this._algorand.send.appCall(this.params.bare.optIn(params));
-			},
-			delete: (params) => {
-				return this._algorand.send.appDelete(this.params.bare.delete(params));
-			},
-			clearState: (params) => {
-				return this._algorand.send.appCall(this.params.bare.clearState(params));
-			},
-			closeOut: (params) => {
-				return this._algorand.send.appCall(this.params.bare.closeOut(params));
-			},
-			call: (params) => {
-				return this._algorand.send.appCall(this.params.bare.call(params));
-			}
-		};
-	}
-	getMethodCallParamsMethods() {
-		return {
-			fundAppAccount: (params) => {
-				return {
-					...params,
-					sender: this.getSender(params.sender),
-					signer: this.getSigner(params.sender, params.signer),
-					receiver: this.appAddress
-				};
-			},
-			update: async (params) => {
-				return await this.getABIParams({
-					...params,
-					...await this.compile(params)
-				}, require_app_call.OnApplicationComplete.UpdateApplication);
-			},
-			optIn: async (params) => {
-				return await this.getABIParams(params, require_app_call.OnApplicationComplete.OptIn);
-			},
-			delete: async (params) => {
-				return await this.getABIParams(params, require_app_call.OnApplicationComplete.DeleteApplication);
-			},
-			closeOut: async (params) => {
-				return await this.getABIParams(params, require_app_call.OnApplicationComplete.CloseOut);
-			},
-			call: async (params) => {
-				return await this.getABIParams(params, params.onComplete ?? require_app_call.OnApplicationComplete.NoOp);
-			}
-		};
-	}
-	getMethodCallSendMethods() {
-		return {
-			fundAppAccount: (params) => {
-				return this._algorand.send.payment(this.params.fundAppAccount(params));
-			},
-			update: async (params) => {
-				const compiled = await this.compile(params);
-				return {
-					...await this.processMethodCallReturn(this._algorand.send.appUpdateMethodCall(await this.params.update({ ...params }))),
-					...compiled
-				};
-			},
-			optIn: async (params) => {
-				return this.processMethodCallReturn(this._algorand.send.appCallMethodCall(await this.params.optIn(params)));
-			},
-			delete: async (params) => {
-				return this.processMethodCallReturn(this._algorand.send.appDeleteMethodCall(await this.params.delete(params)));
-			},
-			closeOut: async (params) => {
-				return this.processMethodCallReturn(this._algorand.send.appCallMethodCall(await this.params.closeOut(params)));
-			},
-			call: async (params) => {
-				if ((params.onComplete === require_app_call.OnApplicationComplete.NoOp || !params.onComplete) && require_abi_method.getABIMethod(params.method, this._appSpec).readonly) {
-					const readonlyParams = { ...params };
-					if (params.coverAppCallInnerTransactionFees && params.maxFee) {
-						readonlyParams.staticFee = params.maxFee;
-						readonlyParams.extraFee = void 0;
-					}
-					try {
-						const result = await this._algorand.newGroup().addAppCallMethodCall(await this.params.call(readonlyParams)).simulate({
-							allowUnnamedResources: params.populateAppCallResources ?? true,
-							skipSignatures: true,
-							extraOpcodeBudget: MAX_SIMULATE_OPCODE_BUDGET
-						});
-						return this.processMethodCallReturn({
-							...result,
-							transaction: result.transactions.at(-1),
-							confirmation: result.confirmations.at(-1),
-							return: result.returns && result.returns.length > 0 ? result.returns.at(-1) : void 0
-						});
-					} catch (e) {
-						const error = e;
-						if (params.coverAppCallInnerTransactionFees && error && error.message && error.message.match(/fee too small/)) throw Error(`Fees were too small. You may need to increase the transaction maxFee.`);
-						throw e;
-					}
-				}
-				return this.processMethodCallReturn(this._algorand.send.appCallMethodCall(await this.params.call(params)));
-			}
-		};
-	}
-	getMethodCallCreateTransactionMethods() {
-		return {
-			fundAppAccount: (params) => {
-				return this._algorand.createTransaction.payment(this.params.fundAppAccount(params));
-			},
-			update: async (params) => {
-				return this._algorand.createTransaction.appUpdateMethodCall(await this.params.update(params));
-			},
-			optIn: async (params) => {
-				return this._algorand.createTransaction.appCallMethodCall(await this.params.optIn(params));
-			},
-			delete: async (params) => {
-				return this._algorand.createTransaction.appDeleteMethodCall(await this.params.delete(params));
-			},
-			closeOut: async (params) => {
-				return this._algorand.createTransaction.appCallMethodCall(await this.params.closeOut(params));
-			},
-			call: async (params) => {
-				return this._algorand.createTransaction.appCallMethodCall(await this.params.call(params));
-			}
-		};
-	}
-	/** Returns the sender for a call, using the provided sender or using the `defaultSender`
-	* if none provided and throws an error if neither provided */
-	getSender(sender) {
-		if (!sender && !this._defaultSender) throw new Error(`No sender provided and no default sender present in app client for call to app ${this._appName}`);
-		return require_address.getAddress(sender ?? this._defaultSender);
-	}
-	/** Returns the signer for a call, using the provided signer or the `defaultSigner`
-	* if no signer was provided and the sender resolves to the default sender, the call will use default signer
-	* or `undefined` otherwise (so the signer is resolved from `AlgorandClient`) */
-	getSigner(sender, signer) {
-		return signer ?? (!sender || sender === this._defaultSender ? this._defaultSigner : void 0);
-	}
-	getBareParams(params, onComplete) {
-		return {
-			...params,
-			appId: this._appId,
-			sender: this.getSender(params?.sender),
-			signer: this.getSigner(params?.sender, params?.signer),
-			onComplete
-		};
-	}
-	async getABIParams(params, onComplete) {
-		const sender = this.getSender(params.sender);
-		const method = require_abi_method.getABIMethod(params.method, this._appSpec);
-		const args = await this.getABIArgsWithDefaultValues(params.method, params.args, sender);
-		return {
-			...params,
-			appId: this._appId,
-			sender,
-			signer: this.getSigner(params.sender, params.signer),
-			method,
-			onComplete,
-			args
-		};
-	}
-	/** Make the given call and catch any errors, augmenting with debugging information before re-throwing. */
-	handleCallErrors = async (e) => {
-		if (this.appId === 0n) {
-			if (e.sentTransactions === void 0) return e;
-			const txn = e.sentTransactions.find((t) => e.message.includes(t.txId()));
-			const programsDefinedAndEqual = (a, b) => {
-				if (a === void 0 || b === void 0) return false;
-				if (a.length !== b.length) return false;
-				for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-				return true;
-			};
-			if (!programsDefinedAndEqual(txn?.appCall?.clearStateProgram, this._lastCompiled.clear) || !programsDefinedAndEqual(txn?.appCall?.approvalProgram, this._lastCompiled?.approval)) return e;
-		} else {
-			const appIdString = `app=${this._appId.toString()}`;
-			if (!e.message.includes(appIdString)) return e;
-		}
-		const logicError = await this.exposeLogicError(e);
-		if (logicError instanceof require_logic_error.LogicError) {
-			let currentLine = logicError.teal_line - logicError.lines - 1;
-			const stackWithLines = logicError.stack?.split("\n").map((line) => `${currentLine += 1}: ${line}`).join("\n");
-			require_config.Config.logger.error(`${logicError.message}\n\n${stackWithLines}`);
-		}
-		return logicError;
-	};
-	getBoxMethods() {
-		const that = this;
-		const stateMethods = {
-			getAll: async () => {
-				return Object.fromEntries(await Promise.all(Object.keys(that._appSpec.state.keys.box).map(async (key) => [key, await stateMethods.getValue(key)])));
-			},
-			getValue: async (name) => {
-				const metadata = require_arc56_contract.getBoxABIStorageKey(that._appSpec, name);
-				const value = await that.getBoxValue(buffer.Buffer.from(metadata.key, "base64"));
-				return require_abi_method.getABIDecodedValue(metadata.valueType, value);
-			},
-			getMapValue: async (mapName, key) => {
-				const metadata = require_arc56_contract.getBoxABIStorageMap(that._appSpec, mapName);
-				const prefix = buffer.Buffer.from(metadata.prefix ?? "", "base64");
-				const encodedKey = buffer.Buffer.concat([prefix, require_abi_method.getABIEncodedValue(metadata.keyType, key)]);
-				const base64Key = buffer.Buffer.from(encodedKey).toString("base64");
-				const value = await that.getBoxValue(buffer.Buffer.from(base64Key, "base64"));
-				return require_abi_method.getABIDecodedValue(metadata.valueType, value);
-			},
-			getMap: async (mapName) => {
-				const metadata = require_arc56_contract.getBoxABIStorageMap(that._appSpec, mapName);
-				const prefix = buffer.Buffer.from(metadata.prefix ?? "", "base64");
-				const boxNames = await that.getBoxNames();
-				return new Map(await Promise.all(boxNames.filter((b) => require_util.binaryStartsWith(b.nameRaw, prefix)).map(async (b) => {
-					return [require_abi_method.getABIDecodedValue(metadata.keyType, b.nameRaw.slice(prefix.length)), require_abi_method.getABIDecodedValue(metadata.valueType, await that.getBoxValue(b.nameRaw))];
-				})));
-			}
-		};
-		return stateMethods;
-	}
-	getStateMethods(stateGetter, keyGetter, mapGetter) {
-		const stateMethods = {
-			getAll: async () => {
-				const appState = await stateGetter();
-				return Object.fromEntries(await Promise.all(Object.keys(keyGetter()).map(async (key) => [key, await stateMethods.getValue(key, appState)])));
-			},
-			getValue: async (name, appState) => {
-				const state = Object.values(appState ?? await stateGetter());
-				const metadata = keyGetter()[name];
-				if (metadata === void 0) throw new Error(`Attempted to get state value ${name}, but it does not exist`);
-				const value = state.find((s) => s.keyBase64 === metadata.key);
-				if (value && "valueRaw" in value) return require_abi_method.getABIDecodedValue(metadata.valueType, value.valueRaw);
-				return value?.value;
-			},
-			getMapValue: async (mapName, key, appState) => {
-				const state = Object.values(appState ?? await stateGetter());
-				const metadata = mapGetter()[mapName];
-				const prefix = buffer.Buffer.from(metadata.prefix ?? "", "base64");
-				const encodedKey = buffer.Buffer.concat([prefix, require_abi_method.getABIEncodedValue(metadata.keyType, key)]);
-				const base64Key = buffer.Buffer.from(encodedKey).toString("base64");
-				const value = state.find((s) => s.keyBase64 === base64Key);
-				if (value && "valueRaw" in value) return require_abi_method.getABIDecodedValue(metadata.valueType, value.valueRaw);
-				return value?.value;
-			},
-			getMap: async (mapName) => {
-				const state = Object.values(await stateGetter());
-				const metadata = mapGetter()[mapName];
-				const prefix = buffer.Buffer.from(metadata.prefix ?? "", "base64");
-				return new Map(state.filter((s) => require_util.binaryStartsWith(s.keyRaw, prefix)).map((s) => {
-					const key = s.keyRaw.slice(prefix.length);
-					return [require_abi_method.getABIDecodedValue(metadata.keyType, key), "valueRaw" in s ? require_abi_method.getABIDecodedValue(metadata.valueType, s.valueRaw) : s.value];
-				}));
-			}
-		};
-		return stateMethods;
-	}
-};
+/** @deprecated Import from `@algorandfoundation/algokit-utils/app-client` instead */
+const AppClient = require_app_client.AppClient;
 
 //#endregion
 exports.AppClient = AppClient;