@algorandfoundation/algokit-utils 9.2.0-beta.7 → 10.0.0-alpha.1

package/packages/algod_client/src/apis/api-service.js

@@ -0,0 +1,627 @@
+const require_array = require('../../../common/src/array.js');
+const require_signed_transaction = require('../../../transact/src/transactions/signed-transaction.js');
+const require_model_runtime = require('../core/model-runtime.js');
+const require_genesis = require('../models/genesis.js');
+const require_ledger_state_delta = require('../models/ledger-state-delta.js');
+const require_application = require('../models/application.js');
+const require_asset = require('../models/asset.js');
+const require_account = require('../models/account.js');
+const require_simulate_request = require('../models/simulate-request.js');
+const require_box = require('../models/box.js');
+const require_version = require('../models/version.js');
+const require_pending_transaction_response = require('../models/pending-transaction-response.js');
+const require_state_proof = require('../models/state-proof.js');
+const require_light_block_header_proof = require('../models/light-block-header-proof.js');
+const require_transaction_proof = require('../models/transaction-proof.js');
+const require_get_block_time_stamp_offset_response = require('../models/get-block-time-stamp-offset-response.js');
+const require_get_sync_round_response = require('../models/get-sync-round-response.js');
+const require_transaction_group_ledger_state_deltas_for_round_response = require('../models/transaction-group-ledger-state-deltas-for-round-response.js');
+const require_account_asset_response = require('../models/account-asset-response.js');
+const require_account_application_response = require('../models/account-application-response.js');
+const require_block_response = require('../models/block-response.js');
+const require_block_txids_response = require('../models/block-txids-response.js');
+const require_block_hash_response = require('../models/block-hash-response.js');
+const require_node_status_response = require('../models/node-status-response.js');
+const require_pending_transactions_response = require('../models/pending-transactions-response.js');
+const require_post_transactions_response = require('../models/post-transactions-response.js');
+const require_simulate_response = require('../models/simulate-response.js');
+const require_supply_response = require('../models/supply-response.js');
+const require_transaction_parameters_response = require('../models/transaction-parameters-response.js');
+const require_boxes_response = require('../models/boxes-response.js');
+const require_compile_response = require('../models/compile-response.js');
+const require_disassemble_response = require('../models/disassemble-response.js');
+
+//#region packages/algod_client/src/apis/api-service.ts
+var AlgodApi = class {
+	constructor(httpRequest) {
+		this.httpRequest = httpRequest;
+	}
+	mimeTypeFor(format) {
+		return format === "json" ? "application/json" : format === "msgpack" ? "application/msgpack" : "text/plain";
+	}
+	/**
+	* Given a specific account public key and application ID, this call returns the account's application local state and global state (AppLocalState and AppParams, if either exists). Global state will only be returned if the provided address is the application's creator.
+	*/
+	async accountApplicationInformation(address, applicationId) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/accounts/{address}/applications/{application-id}",
+			path: {
+				address,
+				"application-id": applicationId
+			},
+			query: {},
+			headers,
+			body: void 0
+		}), require_account_application_response.AccountApplicationResponseMeta);
+	}
+	/**
+	* Given a specific account public key and asset ID, this call returns the account's asset holding and asset parameters (if either exist). Asset parameters will only be returned if the provided address is the asset's creator.
+	*/
+	async accountAssetInformation(address, assetId) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/accounts/{address}/assets/{asset-id}",
+			path: {
+				address,
+				"asset-id": assetId
+			},
+			query: {},
+			headers,
+			body: void 0
+		}), require_account_asset_response.AccountAssetResponseMeta);
+	}
+	/**
+	* Given a specific account public key, this call returns the account's status, balance and spendable amounts
+	*/
+	async accountInformation(address, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/accounts/{address}",
+			path: { address },
+			query: { exclude: params?.exclude },
+			headers,
+			body: void 0
+		}), require_account.AccountMeta);
+	}
+	/**
+	* Given an application ID and box name, it returns the round, box name, and value (each base64 encoded). Box names must be in the goal app call arg encoding form 'encoding:value'. For ints, use the form 'int:1234'. For raw bytes, use the form 'b64:A=='. For printable strings, use the form 'str:hello'. For addresses, use the form 'addr:XYZ...'.
+	*/
+	async _getApplicationBoxByName(applicationId, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/applications/{application-id}/box",
+			path: { "application-id": applicationId },
+			query: { name: params?.name },
+			headers,
+			body: void 0
+		}), require_box.BoxMeta);
+	}
+	/**
+	* Given an application ID, return all Box names. No particular ordering is guaranteed. Request fails when client or server-side configured limits prevent returning all Box names.
+	*/
+	async getApplicationBoxes(applicationId, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/applications/{application-id}/boxes",
+			path: { "application-id": applicationId },
+			query: { max: params?.max },
+			headers,
+			body: void 0
+		}), require_boxes_response.BoxesResponseMeta);
+	}
+	/**
+	* Given a application ID, it returns application information including creator, approval and clear programs, global and local schemas, and global state.
+	*/
+	async getApplicationById(applicationId) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/applications/{application-id}",
+			path: { "application-id": applicationId },
+			query: {},
+			headers,
+			body: void 0
+		}), require_application.ApplicationMeta);
+	}
+	/**
+	* Given a asset ID, it returns asset information including creator, name, total supply and special addresses.
+	*/
+	async getAssetById(assetId) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/assets/{asset-id}",
+			path: { "asset-id": assetId },
+			query: {},
+			headers,
+			body: void 0
+		}), require_asset.AssetMeta);
+	}
+	async getBlock(round, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/blocks/{round}",
+			path: { round },
+			query: {
+				"header-only": params?.headerOnly,
+				format: "msgpack"
+			},
+			headers,
+			body: void 0
+		}), require_block_response.BlockResponseMeta);
+	}
+	async getBlockHash(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/blocks/{round}/hash",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		}), require_block_hash_response.BlockHashResponseMeta);
+	}
+	/**
+	* Gets the current timestamp offset.
+	*/
+	async getBlockTimeStampOffset() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/devmode/blocks/offset",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_get_block_time_stamp_offset_response.GetBlockTimeStampOffsetResponseMeta);
+	}
+	async getBlockTxIds(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/blocks/{round}/txids",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		}), require_block_txids_response.BlockTxidsResponseMeta);
+	}
+	/**
+	* Returns the entire genesis file in json.
+	*/
+	async getGenesis() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/genesis",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_genesis.GenesisMeta);
+	}
+	/**
+	* Get ledger deltas for a round.
+	*/
+	async getLedgerStateDelta(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/deltas/{round}",
+			path: { round },
+			query: { format: "msgpack" },
+			headers,
+			body: void 0
+		}), require_ledger_state_delta.LedgerStateDeltaMeta);
+	}
+	/**
+	* Get a ledger delta for a given transaction group.
+	*/
+	async getLedgerStateDeltaForTransactionGroup(id) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/deltas/txn/group/{id}",
+			path: { id },
+			query: { format: "msgpack" },
+			headers,
+			body: void 0
+		}), require_ledger_state_delta.LedgerStateDeltaMeta);
+	}
+	async getLightBlockHeaderProof(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/blocks/{round}/lightheader/proof",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		}), require_light_block_header_proof.LightBlockHeaderProofMeta);
+	}
+	/**
+	* Get the list of pending transactions, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.
+	*/
+	async getPendingTransactions(params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/transactions/pending",
+			path: {},
+			query: {
+				max: params?.max,
+				format: "msgpack"
+			},
+			headers,
+			body: void 0
+		}), require_pending_transactions_response.PendingTransactionsResponseMeta);
+	}
+	/**
+	* Get the list of pending transactions by address, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.
+	*/
+	async getPendingTransactionsByAddress(address, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/accounts/{address}/transactions/pending",
+			path: { address },
+			query: {
+				max: params?.max,
+				format: "msgpack"
+			},
+			headers,
+			body: void 0
+		}), require_pending_transactions_response.PendingTransactionsResponseMeta);
+	}
+	async getReady() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		await this.httpRequest.request({
+			method: "GET",
+			url: "/ready",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		});
+	}
+	async getStateProof(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/stateproofs/{round}",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		}), require_state_proof.StateProofMeta);
+	}
+	async getStatus() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/status",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_node_status_response.NodeStatusResponseMeta);
+	}
+	async getSupply() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/ledger/supply",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_supply_response.SupplyResponseMeta);
+	}
+	/**
+	* Gets the minimum sync round for the ledger.
+	*/
+	async getSyncRound() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/ledger/sync",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_get_sync_round_response.GetSyncRoundResponseMeta);
+	}
+	/**
+	* Get ledger deltas for transaction groups in a given round.
+	*/
+	async getTransactionGroupLedgerStateDeltasForRound(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/deltas/{round}/txn/group",
+			path: { round },
+			query: { format: "msgpack" },
+			headers,
+			body: void 0
+		}), require_transaction_group_ledger_state_deltas_for_round_response.TransactionGroupLedgerStateDeltasForRoundResponseMeta);
+	}
+	async getTransactionProof(round, txId, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/blocks/{round}/transactions/{txid}/proof",
+			path: {
+				round,
+				txid: txId
+			},
+			query: { hashtype: params?.hashtype },
+			headers,
+			body: void 0
+		}), require_transaction_proof.TransactionProofMeta);
+	}
+	/**
+	* Retrieves the supported API versions, binary build versions, and genesis information.
+	*/
+	async getVersion() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/versions",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_version.VersionMeta);
+	}
+	async healthCheck() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		await this.httpRequest.request({
+			method: "GET",
+			url: "/health",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		});
+	}
+	/**
+	* Given a transaction ID of a recently submitted transaction, it returns information about it.  There are several cases when this might succeed:
+	* - transaction committed (committed round > 0)
+	* - transaction still in the pool (committed round = 0, pool error = "")
+	* - transaction removed from pool due to error (committed round = 0, pool error != "")
+	* Or the transaction may have happened sufficiently long ago that the node no longer remembers it, and this will return an error.
+	*/
+	async pendingTransactionInformation(txId) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("msgpack");
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/transactions/pending/{txid}",
+			path: { txid: txId },
+			query: { format: "msgpack" },
+			headers,
+			body: void 0
+		}), require_pending_transaction_response.PendingTransactionResponseMeta);
+	}
+	async _rawTransaction(body) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		const serializedBody = body ?? void 0;
+		headers["Content-Type"] = "application/x-binary";
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/transactions",
+			path: {},
+			query: {},
+			headers,
+			body: serializedBody
+		}), require_post_transactions_response.PostTransactionsResponseMeta);
+	}
+	/**
+	* Sets the timestamp offset (seconds) for blocks in dev mode. Providing an offset of 0 will unset this value and try to use the real clock for the timestamp.
+	*/
+	async setBlockTimeStampOffset(offset) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/devmode/blocks/offset/{offset}",
+			path: { offset },
+			query: {},
+			headers,
+			body: void 0
+		});
+	}
+	/**
+	* Sets the minimum sync round on the ledger.
+	*/
+	async setSyncRound(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/ledger/sync/{round}",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		});
+	}
+	async simulateTransactions(body) {
+		const headers = {};
+		const responseFormat = "msgpack";
+		headers["Accept"] = this.mimeTypeFor(responseFormat);
+		const bodyMeta = require_simulate_request.SimulateRequestMeta;
+		const mediaType = this.mimeTypeFor(!bodyMeta ? "text" : responseFormat);
+		if (mediaType) headers["Content-Type"] = mediaType;
+		const serializedBody = body ? require_model_runtime.encodeMsgpack(body, bodyMeta) : void 0;
+		return require_model_runtime.decodeMsgpack(await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/transactions/simulate",
+			path: {},
+			query: { format: "msgpack" },
+			headers,
+			body: serializedBody
+		}), require_simulate_response.SimulateResponseMeta);
+	}
+	/**
+	* Waits for a block to appear after round {round} and returns the node's status at the time. There is a 1 minute timeout, when reached the current status is returned regardless of whether or not it is the round after the given round.
+	*/
+	async statusAfterBlock(round) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/status/wait-for-block-after/{round}",
+			path: { round },
+			query: {},
+			headers,
+			body: void 0
+		}), require_node_status_response.NodeStatusResponseMeta);
+	}
+	/**
+	* Given TEAL source code in plain text, return base64 encoded program bytes and base32 SHA512_256 hash of program bytes (Address style). This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.
+	*/
+	async tealCompile(body, params) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		const mediaType = this.mimeTypeFor("text");
+		if (mediaType) headers["Content-Type"] = mediaType;
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/teal/compile",
+			path: {},
+			query: { sourcemap: params?.sourcemap },
+			headers,
+			body
+		}), require_compile_response.CompileResponseMeta);
+	}
+	/**
+	* Given the program bytes, return the TEAL source code in plain text. This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.
+	*/
+	async tealDisassemble(body) {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		const serializedBody = body ?? void 0;
+		headers["Content-Type"] = "application/x-binary";
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "POST",
+			url: "/v2/teal/disassemble",
+			path: {},
+			query: {},
+			headers,
+			body: serializedBody
+		}), require_disassemble_response.DisassembleResponseMeta);
+	}
+	async _transactionParams() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		return require_model_runtime.decodeJson(await this.httpRequest.request({
+			method: "GET",
+			url: "/v2/transactions/params",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		}), require_transaction_parameters_response.TransactionParametersResponseMeta);
+	}
+	/**
+	* Unset the ledger sync round.
+	*/
+	async unsetSyncRound() {
+		const headers = {};
+		headers["Accept"] = this.mimeTypeFor("json");
+		await this.httpRequest.request({
+			method: "DELETE",
+			url: "/v2/ledger/sync",
+			path: {},
+			query: {},
+			headers,
+			body: void 0
+		});
+	}
+	/**
+	* Send a signed transaction or array of signed transactions to the network.
+	*/
+	async sendRawTransaction(stxOrStxs) {
+		let rawTransactions = stxOrStxs;
+		if (Array.isArray(stxOrStxs)) {
+			if (!stxOrStxs.every((a) => a instanceof Uint8Array)) throw new Error("Array elements must be byte arrays");
+			rawTransactions = require_array.concatArrays(...stxOrStxs);
+		} else if (!(rawTransactions instanceof Uint8Array)) throw new Error("Argument must be byte array");
+		return this._rawTransaction(rawTransactions);
+	}
+	/**
+	* Given an application ID and box name, it returns the round, box name, and value.
+	*/
+	async getApplicationBoxByName(applicationId, boxName) {
+		const name = `b64:${Buffer.from(boxName).toString("base64")}`;
+		return this._getApplicationBoxByName(applicationId, { name });
+	}
+	/**
+	* Returns the common needed parameters for a new transaction.
+	*/
+	async suggestedParams() {
+		const txnParams = await this._transactionParams();
+		return {
+			flatFee: false,
+			fee: txnParams.fee,
+			firstValid: txnParams.lastRound,
+			lastValid: txnParams.lastRound + 1000n,
+			genesisHash: txnParams.genesisHash,
+			genesisId: txnParams.genesisId,
+			minFee: txnParams.minFee,
+			consensusVersion: txnParams.consensusVersion
+		};
+	}
+	/**
+	* Returns the common needed parameters for a new transaction.
+	*/
+	async getTransactionParams() {
+		return await this.suggestedParams();
+	}
+	/**
+	* Simulate an encoded signed transaction or array of encoded signed transactions.
+	*/
+	async simulateRawTransactions(stxOrStxs) {
+		const txns = Array.isArray(stxOrStxs) ? stxOrStxs.map((stxn) => require_signed_transaction.decodeSignedTransaction(stxn)) : [require_signed_transaction.decodeSignedTransaction(stxOrStxs)];
+		return this.simulateTransactions({ txnGroups: [{ txns }] });
+	}
+};
+
+//#endregion
+exports.AlgodApi = AlgodApi;
+//# sourceMappingURL=api-service.js.map