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

package/app-client.mjs

@@ -0,0 +1,908 @@
+import { getAddress, getApplicationAddress, getOptionalAddress } from "./packages/common/src/address.mjs";
+import { Config } from "./config.mjs";
+import { asJson, binaryStartsWith } from "./util.mjs";
+import { ProgramSourceMap } from "./packages/common/src/sourcemap.mjs";
+import { OnApplicationComplete } from "./packages/transact/src/transactions/app-call.mjs";
+import { EventType } from "./lifecycle-events.mjs";
+import { argTypeIsTransaction, getABIDecodedValue, getABIEncodedValue, getABIMethod } from "./packages/abi/src/abi-method.mjs";
+import { getBoxABIStorageKey, getBoxABIStorageKeys, getBoxABIStorageMap, getGlobalABIStorageKeys, getGlobalABIStorageMaps, getLocalABIStorageKeys, getLocalABIStorageMaps } from "./packages/abi/src/arc56-contract.mjs";
+import { arc32ToArc56 } from "./app-spec.mjs";
+import { LogicError } from "./logic-error.mjs";
+import { Buffer } from "buffer";
+
+//#region src/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 = 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 = 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), () => getLocalABIStorageKeys(this._appSpec), () => getLocalABIStorageMaps(this._appSpec));
+		this._globalStateMethods = this.getStateMethods(() => this.getGlobalState(), () => getGlobalABIStorageKeys(this._appSpec), () => 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 ${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 ? 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, 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 ProgramSourceMap(sourceMaps.approvalSourceMap);
+		this._clearSourceMap = new 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 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 = 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 LogicError(errorDetails, Buffer.from(isClearStateProgram ? appSpec.source.clear : appSpec.source.approval, "base64").toString().split("\n"), getLineForPc);
+		}
+		if (errorMessage) {
+			const appId = asJson(e).match(/(?<=app=)\d+/)?.[0] || "";
+			const txId = 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.from(appSpec.byteCode.approval, "base64"),
+				clearStateProgram: Buffer.from(appSpec.byteCode.clear, "base64")
+			};
+		}
+		const approvalTemplate = Buffer.from(appSpec.source.approval, "base64").toString("utf-8");
+		const compiledApproval = await appManager.compileTealTemplate(approvalTemplate, deployTimeParams, {
+			updatable,
+			deletable
+		});
+		const clearTemplate = Buffer.from(appSpec.source.clear, "base64").toString("utf-8");
+		const compiledClear = await appManager.compileTealTemplate(clearTemplate, deployTimeParams);
+		if (Config.debug) await Config.events.emitAsync(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 = 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 (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.from(defaultValue.data, "base64");
+					return 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" ? getBoxABIStorageKeys(this.appSpec) : defaultValue.source === "global" ? getGlobalABIStorageKeys(this.appSpec) : 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.from(defaultValue.data, "base64"));
+			return 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 ? getABIDecodedValue(key.valueType, value.valueRaw) : value.value;
+	}
+	getBareParamsMethods() {
+		return {
+			update: async (params) => {
+				return this.getBareParams({
+					...params,
+					...await this.compile(params)
+				}, OnApplicationComplete.UpdateApplication);
+			},
+			optIn: (params) => {
+				return this.getBareParams(params, OnApplicationComplete.OptIn);
+			},
+			delete: (params) => {
+				return this.getBareParams(params, OnApplicationComplete.DeleteApplication);
+			},
+			clearState: (params) => {
+				return this.getBareParams(params, OnApplicationComplete.ClearState);
+			},
+			closeOut: (params) => {
+				return this.getBareParams(params, OnApplicationComplete.CloseOut);
+			},
+			call: (params) => {
+				return this.getBareParams(params, params?.onComplete ?? 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)
+				}, OnApplicationComplete.UpdateApplication);
+			},
+			optIn: async (params) => {
+				return await this.getABIParams(params, OnApplicationComplete.OptIn);
+			},
+			delete: async (params) => {
+				return await this.getABIParams(params, OnApplicationComplete.DeleteApplication);
+			},
+			closeOut: async (params) => {
+				return await this.getABIParams(params, OnApplicationComplete.CloseOut);
+			},
+			call: async (params) => {
+				return await this.getABIParams(params, params.onComplete ?? 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 === OnApplicationComplete.NoOp || !params.onComplete) && 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 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 = 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 LogicError) {
+			let currentLine = logicError.teal_line - logicError.lines - 1;
+			const stackWithLines = logicError.stack?.split("\n").map((line) => `${currentLine += 1}: ${line}`).join("\n");
+			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 = getBoxABIStorageKey(that._appSpec, name);
+				const value = await that.getBoxValue(Buffer.from(metadata.key, "base64"));
+				return getABIDecodedValue(metadata.valueType, value);
+			},
+			getMapValue: async (mapName, key) => {
+				const metadata = getBoxABIStorageMap(that._appSpec, mapName);
+				const prefix = Buffer.from(metadata.prefix ?? "", "base64");
+				const encodedKey = Buffer.concat([prefix, getABIEncodedValue(metadata.keyType, key)]);
+				const base64Key = Buffer.from(encodedKey).toString("base64");
+				const value = await that.getBoxValue(Buffer.from(base64Key, "base64"));
+				return getABIDecodedValue(metadata.valueType, value);
+			},
+			getMap: async (mapName) => {
+				const metadata = getBoxABIStorageMap(that._appSpec, mapName);
+				const prefix = Buffer.from(metadata.prefix ?? "", "base64");
+				const boxNames = await that.getBoxNames();
+				return new Map(await Promise.all(boxNames.filter((b) => binaryStartsWith(b.nameRaw, prefix)).map(async (b) => {
+					return [getABIDecodedValue(metadata.keyType, b.nameRaw.slice(prefix.length)), 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 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.from(metadata.prefix ?? "", "base64");
+				const encodedKey = Buffer.concat([prefix, getABIEncodedValue(metadata.keyType, key)]);
+				const base64Key = Buffer.from(encodedKey).toString("base64");
+				const value = state.find((s) => s.keyBase64 === base64Key);
+				if (value && "valueRaw" in value) return getABIDecodedValue(metadata.valueType, value.valueRaw);
+				return value?.value;
+			},
+			getMap: async (mapName) => {
+				const state = Object.values(await stateGetter());
+				const metadata = mapGetter()[mapName];
+				const prefix = Buffer.from(metadata.prefix ?? "", "base64");
+				return new Map(state.filter((s) => binaryStartsWith(s.keyRaw, prefix)).map((s) => {
+					const key = s.keyRaw.slice(prefix.length);
+					return [getABIDecodedValue(metadata.keyType, key), "valueRaw" in s ? getABIDecodedValue(metadata.valueType, s.valueRaw) : s.value];
+				}));
+			}
+		};
+		return stateMethods;
+	}
+};
+
+//#endregion
+export { AppClient };
+//# sourceMappingURL=app-client.mjs.map