@txnlab/haystack-router 2.0.0

package/dist/index.mjs

@@ -0,0 +1,1028 @@
+import { t as Logger } from "./logger-DUVOA2Oo.mjs";
+import { Algodv2, AtomicTransactionComposer, LogicSigAccount, Transaction, decodeUnsignedTransaction, isValidAddress, makeApplicationOptInTxnFromObject, makeAssetTransferTxnWithSuggestedParamsFromObject, msgpackRawDecode, signLogicSigTransactionObject, signTransaction } from "algosdk";
+
+//#region src/constants.ts
+/**
+* Supported DEX protocols for swap routing
+*/
+let Protocol = /* @__PURE__ */ function(Protocol$1) {
+	Protocol$1["TinymanV2"] = "TinymanV2";
+	Protocol$1["Algofi"] = "Algofi";
+	Protocol$1["Algomint"] = "Algomint";
+	Protocol$1["Pact"] = "Pact";
+	Protocol$1["Folks"] = "Folks";
+	Protocol$1["TAlgo"] = "TAlgo";
+	return Protocol$1;
+}({});
+/**
+* Deprecated protocols that are automatically excluded from routing
+*
+* @internal
+*/
+const DEPRECATED_PROTOCOLS = ["Humble", "Tinyman"];
+/** Default Algod node URI for mainnet */
+const DEFAULT_ALGOD_URI = "https://mainnet-api.4160.nodely.dev/";
+/** Default Algod node token (empty for public nodes) */
+const DEFAULT_ALGOD_TOKEN = "";
+/** Default Algod node port */
+const DEFAULT_ALGOD_PORT = 443;
+/** Default Haystack Router API base URL */
+const DEFAULT_API_BASE_URL = "https://hayrouter.txnlab.dev/api";
+/** Default fee in basis points (0.10%) */
+const DEFAULT_FEE_BPS = 10;
+/** Maximum allowed fee in basis points (3.00%) */
+const MAX_FEE_BPS = 300;
+/** Default maximum transaction group size */
+const DEFAULT_MAX_GROUP_SIZE = 16;
+/** Default maximum routing depth (number of hops) */
+const DEFAULT_MAX_DEPTH = 4;
+/** Default auto opt-in setting (automatic asset/app opt-in detection) */
+const DEFAULT_AUTO_OPT_IN = false;
+/** Default debug level (no debug logging) */
+const DEFAULT_DEBUG_LEVEL = "none";
+/** Default number of rounds to wait for transaction confirmation */
+const DEFAULT_CONFIRMATION_ROUNDS = 10;
+
+//#endregion
+//#region src/composer.ts
+/**
+* Status of the SwapComposer transaction group lifecycle
+*/
+let SwapComposerStatus = /* @__PURE__ */ function(SwapComposerStatus$1) {
+	/** The atomic group is still under construction. */
+	SwapComposerStatus$1[SwapComposerStatus$1["BUILDING"] = 0] = "BUILDING";
+	/** The atomic group has been finalized, but not yet signed. */
+	SwapComposerStatus$1[SwapComposerStatus$1["BUILT"] = 1] = "BUILT";
+	/** The atomic group has been finalized and signed, but not yet submitted to the network. */
+	SwapComposerStatus$1[SwapComposerStatus$1["SIGNED"] = 2] = "SIGNED";
+	/** The atomic group has been finalized, signed, and submitted to the network. */
+	SwapComposerStatus$1[SwapComposerStatus$1["SUBMITTED"] = 3] = "SUBMITTED";
+	/** The atomic group has been finalized, signed, submitted, and successfully committed to a block. */
+	SwapComposerStatus$1[SwapComposerStatus$1["COMMITTED"] = 4] = "COMMITTED";
+	return SwapComposerStatus$1;
+}({});
+/**
+* Composer for building and executing atomic swap transaction groups
+*
+* The SwapComposer allows you to build complex transaction groups by adding custom
+* transactions before and after swap transactions. It handles pre-signed transactions,
+* automatic app opt-ins, and provides a fluent API for transaction group construction.
+*
+* @example
+* ```typescript
+* const quote = await router.fetchQuote({ ... })
+* const composer = await router.newSwap({ quote, address, slippage, signer })
+*
+* await composer
+*   .addTransaction(customTxn)
+*   .addSwapTransactions()
+*   .execute()
+* ```
+*/
+var SwapComposer = class SwapComposer {
+	/** The ATC used to compose the group */
+	atc = new AtomicTransactionComposer();
+	/** The maximum size of an atomic transaction group. */
+	static MAX_GROUP_SIZE = AtomicTransactionComposer.MAX_GROUP_SIZE;
+	/** Whether the swap transactions have been added to the atomic group. */
+	swapTransactionsAdded = false;
+	quote;
+	requiredAppOptIns;
+	swapTxns;
+	algodClient;
+	address;
+	signer;
+	middleware;
+	note;
+	inputTransactionIndex;
+	outputTransactionIndex;
+	/** Summary data built incrementally during swap composition */
+	summaryData;
+	/**
+	* Create a new SwapComposer instance
+	*
+	* Note: Most developers should use RouterClient.newSwap() instead of constructing
+	* this directly, as the factory method handles fetching swap transactions automatically.
+	*
+	* @param config - Configuration for the composer
+	* @param config.quote - The quote response from fetchQuote()
+	* @param config.swapTxns - The swap transactions from fetchSwapTransactions()
+	* @param config.algodClient - Algodv2 client instance
+	* @param config.address - The address of the account that will sign transactions
+	* @param config.signer - Transaction signer function
+	* @param config.middleware - Middleware to apply during swap composition
+	*/
+	constructor(config) {
+		if (config.debugLevel) Logger.setLevel(config.debugLevel);
+		if (!config.quote) throw new Error("Quote is required");
+		if (!config.swapTxns) throw new Error("Swap transactions are required");
+		if (config.swapTxns.length === 0) throw new Error("Swap transactions array cannot be empty");
+		if (!config.algodClient) throw new Error("Algodv2 client instance is required");
+		if (!config.signer) throw new Error("Signer is required");
+		this.quote = config.quote;
+		this.requiredAppOptIns = config.quote.requiredAppOptIns;
+		this.swapTxns = config.swapTxns;
+		this.algodClient = config.algodClient;
+		this.address = this.validateAddress(config.address);
+		this.signer = config.signer;
+		this.middleware = config.middleware ?? [];
+		this.note = config.note;
+	}
+	/**
+	* Get the status of this composer's transaction group
+	*
+	* @returns The current status of the transaction group
+	*/
+	getStatus() {
+		return this.atc.getStatus();
+	}
+	/**
+	* Get the number of transactions currently in this atomic group
+	*
+	* @returns The number of transactions in the group
+	*/
+	count() {
+		return this.atc.count();
+	}
+	/**
+	* Add a transaction to the atomic group
+	*
+	* Transactions are added in the order methods are called. For example:
+	* ```typescript
+	* composer
+	*   .addTransaction(txn1)      // Added first
+	*   .addSwapTransactions()     // Added second
+	*   .addTransaction(txn2)      // Added third
+	* ```
+	*
+	* @param transaction - The transaction to add
+	* @returns This composer instance for chaining
+	* @throws Error if the composer is not in the BUILDING status
+	* @throws Error if the maximum group size is exceeded
+	* @throws Error if attempting to compose with a non-composable swap (Tinyman v1)
+	*/
+	addTransaction(transaction, signer = this.defaultSigner) {
+		if (this.quote.flattenedRoute?.["Tinyman"] !== void 0 && this.quote.flattenedRoute["Tinyman"] > 0) throw new Error("Cannot add transactions to a swap group that uses Tinyman v1. Tinyman v1 produces non-composable transaction groups. Asset opt-ins, opt-outs, and other transactions must be sent in separate groups. If you need to support Tinyman v1 swaps, you must handle multi-group coordination manually.");
+		this.atc.addTransaction({
+			txn: transaction,
+			signer
+		});
+		return this;
+	}
+	/**
+	* Add a method call to the atomic group
+	*
+	* The `signer` property in the `methodCall` parameter is optional. If not provided,
+	* the signer will default to the one passed as the second parameter, or the
+	* configured signer from the constructor if no second parameter is provided.
+	*
+	* @param methodCall - The method call to add
+	* @param signer - The signer to use for the method call (defaults to constructor signer)
+	* @returns This composer instance for chaining
+	* @throws Error if attempting to compose with a non-composable swap (Tinyman v1)
+	*/
+	addMethodCall(methodCall, signer = this.defaultSigner) {
+		if (this.quote.flattenedRoute?.["Tinyman"] !== void 0 && this.quote.flattenedRoute["Tinyman"] > 0) throw new Error("Cannot add method calls to a swap group that uses Tinyman v1. Tinyman v1 produces non-composable transaction groups. Asset opt-ins, opt-outs, and other transactions must be sent in separate groups. If you need to support Tinyman v1 swaps, you must handle multi-group coordination manually.");
+		this.atc.addMethodCall({
+			...methodCall,
+			signer: methodCall.signer ?? signer
+		});
+		return this;
+	}
+	/**
+	* Add swap transactions to the atomic group
+	*
+	* This method automatically processes required app opt-ins, executes middleware hooks,
+	* and adds all swap transactions from the quote. Can only be called once per composer instance.
+	*
+	* Middleware hooks are executed in this order:
+	* 1. beforeSwap() - Add transactions before swap transactions
+	* 2. Swap transactions (from API)
+	* 3. afterSwap() - Add transactions after swap transactions
+	*
+	* @returns This composer instance for chaining
+	* @throws Error if the swap transactions have already been added
+	* @throws Error if the composer is not in the BUILDING status
+	* @throws Error if the maximum group size is exceeded
+	*/
+	async addSwapTransactions() {
+		if (this.swapTransactionsAdded) throw new Error("Swap transactions have already been added");
+		if (this.getStatus() !== SwapComposerStatus.BUILDING) throw new Error("Cannot add swap transactions when composer status is not BUILDING");
+		const beforeTxns = await this.executeMiddlewareHooks("beforeSwap");
+		if (this.atc.count() + beforeTxns.length > SwapComposer.MAX_GROUP_SIZE) throw new Error(`Adding beforeSwap transactions exceeds the maximum atomic group size of ${SwapComposer.MAX_GROUP_SIZE}`);
+		for (const txnWithSigner of beforeTxns) this.atc.addTransaction(txnWithSigner);
+		const { txns: processedTxns, inputTxnRelativeIndex, outputTxnRelativeIndex } = await this.processSwapTransactions();
+		const afterTxns = await this.executeMiddlewareHooks("afterSwap");
+		if (this.atc.count() + processedTxns.length + afterTxns.length > SwapComposer.MAX_GROUP_SIZE) throw new Error(`Adding swap transactions exceeds the maximum atomic group size of ${SwapComposer.MAX_GROUP_SIZE}`);
+		if (inputTxnRelativeIndex !== void 0) this.inputTransactionIndex = this.atc.count() + inputTxnRelativeIndex;
+		if (outputTxnRelativeIndex !== void 0) this.outputTransactionIndex = this.atc.count() + outputTxnRelativeIndex;
+		for (const txnWithSigner of processedTxns) this.atc.addTransaction(txnWithSigner);
+		for (const txnWithSigner of afterTxns) this.atc.addTransaction(txnWithSigner);
+		this.swapTransactionsAdded = true;
+		return this;
+	}
+	/**
+	* Finalize the transaction group by assigning group IDs
+	*
+	* This method builds the atomic transaction group, assigning group IDs to all transactions
+	* if there is more than one transaction. After calling this method, the composer's status
+	* will be at least BUILT.
+	*
+	* @returns Array of transactions with their associated signers
+	*
+	* @throws Error if the group contains 0 transactions
+	*
+	* @example
+	* ```typescript
+	* const composer = await router.newSwap({ quote, address, slippage, signer })
+	* composer.addTransaction(customTxn)
+	*
+	* // Build the group to inspect transactions before signing
+	* const txnsWithSigners = composer.buildGroup()
+	* console.log('Group ID:', txnsWithSigners[0].txn.group)
+	* console.log('Group length:', txnsWithSigners.length)
+	* console.log('Status:', composer.getStatus()) // BUILT
+	* ```
+	*/
+	buildGroup() {
+		return this.atc.buildGroup();
+	}
+	/**
+	* Sign the transaction group
+	*
+	* Automatically adds swap transactions if not already added, builds the atomic group,
+	* and signs all transactions using the configured signer.
+	*
+	* @returns A promise that resolves to an array of signed transaction blobs
+	*
+	* @example
+	* ```typescript
+	* const signedTxns = await composer.sign()
+	* ```
+	*/
+	async sign() {
+		if (this.getStatus() >= SwapComposerStatus.SIGNED) return this.atc.gatherSignatures();
+		if (!this.swapTransactionsAdded) await this.addSwapTransactions();
+		return await this.atc.gatherSignatures();
+	}
+	/**
+	* Submit the signed transactions to the network
+	*
+	* This method signs the transaction group (if not already signed) and submits
+	* it to the Algorand network. Does not wait for confirmation.
+	*
+	* @returns The transaction IDs
+	* @throws Error if the transaction group has already been submitted
+	*
+	* @example
+	* ```typescript
+	* const txIds = await composer.submit()
+	* console.log('Submitted transactions:', txIds)
+	* ```
+	*/
+	async submit() {
+		if (!this.swapTransactionsAdded) await this.addSwapTransactions();
+		return await this.atc.submit(this.algodClient);
+	}
+	/**
+	* Execute the swap
+	*
+	* Signs the transaction group, submits it to the network, and waits for confirmation.
+	* This is the primary method for executing swaps and combines sign(), submit(), and
+	* waitForConfirmation() into a single call.
+	*
+	* @param waitRounds - The number of rounds to wait for confirmation (default: 10)
+	* @returns Object containing the confirmed round and transaction IDs
+	* @throws Error if the transaction group has already been committed
+	*
+	* @example
+	* ```typescript
+	* const result = await composer.execute()
+	* console.log(`Confirmed in round ${result.confirmedRound}`)
+	* console.log('Transaction IDs:', result.txIds)
+	* ```
+	*/
+	async execute(waitRounds = DEFAULT_CONFIRMATION_ROUNDS) {
+		if (!this.swapTransactionsAdded) await this.addSwapTransactions();
+		try {
+			const { txIDs, ...result } = await this.atc.execute(this.algodClient, waitRounds);
+			if (this.summaryData) {
+				if (this.inputTransactionIndex !== void 0) this.summaryData.inputTxnId = txIDs[this.inputTransactionIndex];
+				if (this.outputTransactionIndex !== void 0) this.summaryData.outputTxnId = txIDs[this.outputTransactionIndex];
+			}
+			await this.extractActualOutputAmount();
+			return {
+				...result,
+				txIds: txIDs
+			};
+		} catch (error) {
+			const { logSwapExecutionFailure } = await import("./debug-8aRsrfhx.mjs");
+			logSwapExecutionFailure({
+				quote: this.quote,
+				address: this.address,
+				slippage: 0,
+				transactionCount: this.count(),
+				middlewareCount: this.middleware.length,
+				groupSize: this.count()
+			}, error);
+			throw error;
+		}
+	}
+	/**
+	* Get the transaction ID of the user-signed input transaction
+	*
+	* Returns the transaction ID of the payment or asset transfer transaction
+	* that sends the input asset. This is the transaction whose note field can
+	* be customized via the `note` config option.
+	*
+	* The transaction ID is only available after the group has been built
+	* (after calling buildGroup(), sign(), submit(), or execute()).
+	*
+	* @returns The transaction ID, or undefined if the group hasn't been built yet
+	*          or if the input transaction index couldn't be determined
+	*
+	* @example
+	* ```typescript
+	* const swap = await router.newSwap({
+	*   quote,
+	*   address,
+	*   slippage,
+	*   signer,
+	*   note: new TextEncoder().encode('tracking-123')
+	* })
+	*
+	* await swap.execute()
+	* const inputTxId = swap.getInputTransactionId()
+	* console.log('Input transaction ID:', inputTxId)
+	* ```
+	*/
+	getInputTransactionId() {
+		if (this.getStatus() < SwapComposerStatus.BUILT) return;
+		if (this.inputTransactionIndex === void 0) return;
+		return (this.atc.buildGroup()[this.inputTransactionIndex]?.txn)?.txID();
+	}
+	/**
+	* Get a summary of the swap amounts and fees
+	*
+	* Returns the exact input and output amounts, total transaction fees,
+	* and transaction IDs. This is useful for displaying a complete summary
+	* after a swap has been executed.
+	*
+	* Only available after calling execute() - returns undefined before execution.
+	*
+	* @returns SwapSummary containing exact amounts and fees, or undefined if not yet executed
+	*
+	* @example
+	* ```typescript
+	* const swap = await router.newSwap({ quote, address, slippage, signer })
+	* const result = await swap.execute()
+	*
+	* const summary = swap.getSummary()
+	* if (summary) {
+	*   console.log('Sent:', summary.inputAmount, 'Received:', summary.outputAmount)
+	*   console.log('Total fees:', summary.totalFees, 'microAlgos')
+	* }
+	* ```
+	*/
+	getSummary() {
+		if (!this.summaryData || this.summaryData.outputAmount === void 0 || this.summaryData.inputTxnId === void 0 || this.summaryData.outputTxnId === void 0 || this.summaryData.outputSender === void 0) return;
+		const txns = this.atc.buildGroup();
+		const totalFees = txns.reduce((sum, tws) => sum + tws.txn.fee, 0n);
+		return {
+			inputAssetId: this.summaryData.inputAssetId,
+			outputAssetId: this.summaryData.outputAssetId,
+			inputAmount: this.summaryData.inputAmount,
+			outputAmount: this.summaryData.outputAmount,
+			type: this.quote.type,
+			totalFees,
+			transactionCount: txns.length,
+			inputTxnId: this.summaryData.inputTxnId,
+			outputTxnId: this.summaryData.outputTxnId,
+			inputSender: this.summaryData.inputSender,
+			outputSender: this.summaryData.outputSender
+		};
+	}
+	/**
+	* Validates an Algorand address
+	*/
+	validateAddress(address) {
+		if (!isValidAddress(address)) throw new Error(`Invalid Algorand address: ${address}`);
+		return address;
+	}
+	/**
+	* Processes app opt-ins and decodes swap transactions from API response
+	*
+	* Also initializes summaryData with input transaction details and output transaction ID
+	*/
+	async processSwapTransactions() {
+		const appOptIns = await this.processRequiredAppOptIns();
+		const swapTxns = [];
+		let inputTxnRelativeIndex;
+		let inputTxn;
+		for (let i = 0; i < this.swapTxns.length; i++) {
+			const swapTxn = this.swapTxns[i];
+			if (!swapTxn) continue;
+			try {
+				const txn = decodeUnsignedTransaction(Buffer.from(swapTxn.data, "base64"));
+				delete txn.group;
+				if (swapTxn.signature !== false) swapTxns.push({
+					txn,
+					signer: this.createSwapSigner(swapTxn.signature)
+				});
+				else {
+					if (this.note !== void 0) txn.note = this.note;
+					inputTxnRelativeIndex = appOptIns.length + swapTxns.length;
+					inputTxn = txn;
+					swapTxns.push({
+						txn,
+						signer: this.defaultSigner
+					});
+				}
+			} catch (error) {
+				throw new Error(`Failed to process swap transaction at index ${i}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		if (inputTxn) {
+			const paymentAmount = inputTxn.payment?.amount;
+			const assetTransferAmount = inputTxn.assetTransfer?.amount;
+			const inputAmount = paymentAmount ?? assetTransferAmount ?? 0n;
+			this.summaryData = {
+				inputAssetId: BigInt(this.quote.fromASAID),
+				outputAssetId: BigInt(this.quote.toASAID),
+				inputAmount,
+				inputSender: this.address
+			};
+		}
+		const outputTxnRelativeIndex = swapTxns.length > 0 ? appOptIns.length + swapTxns.length - 1 : void 0;
+		return {
+			txns: [...appOptIns, ...swapTxns],
+			inputTxnRelativeIndex,
+			outputTxnRelativeIndex
+		};
+	}
+	/**
+	* Creates opt-in transactions for apps the user hasn't opted into yet
+	*/
+	async processRequiredAppOptIns() {
+		const userApps = (await this.algodClient.accountInformation(this.address).do())?.appsLocalState?.map((app) => Number(app.id)) || [];
+		const appsToOptIn = this.requiredAppOptIns.filter((appId) => !userApps.includes(appId));
+		if (appsToOptIn.length === 0) return [];
+		const suggestedParams = await this.algodClient.getTransactionParams().do();
+		return appsToOptIn.map((appId) => ({
+			txn: makeApplicationOptInTxnFromObject({
+				sender: this.address,
+				appIndex: appId,
+				suggestedParams
+			}),
+			signer: this.defaultSigner
+		}));
+	}
+	/**
+	* The default signer function that uses the configured signer
+	*/
+	defaultSigner = async (txnGroup, indexesToSign) => {
+		return (await this.signer(txnGroup, indexesToSign)).filter((txn) => txn !== null);
+	};
+	/**
+	* Creates a TransactionSigner function for Deflex pre-signed transactions
+	*/
+	createSwapSigner(signature) {
+		return async (txnGroup, indexesToSign) => {
+			return indexesToSign.map((i) => {
+				const txn = txnGroup[i];
+				if (!txn) throw new Error(`Transaction at index ${i} not found`);
+				return this.signSwapTransaction(txn, signature);
+			});
+		};
+	}
+	/**
+	* Re-signs a Deflex transaction using the provided logic signature or secret key
+	*/
+	signSwapTransaction(transaction, signature) {
+		try {
+			if (signature.type === "logic_signature") {
+				const valueArray = signature.value;
+				const decoded = msgpackRawDecode(new Uint8Array(Object.values(valueArray)));
+				if (!decoded.lsig) throw new Error("Logic signature structure missing lsig field");
+				const lsig = decoded.lsig;
+				return signLogicSigTransactionObject(transaction, new LogicSigAccount(lsig.l, lsig.arg)).blob;
+			} else if (signature.type === "secret_key") {
+				const valueArray = signature.value;
+				return signTransaction(transaction, new Uint8Array(Object.values(valueArray))).blob;
+			} else throw new Error(`Unsupported signature type: ${signature.type}`);
+		} catch (error) {
+			throw new Error(`Failed to re-sign transaction: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	* Execute middleware hooks (beforeSwap or afterSwap)
+	*/
+	async executeMiddlewareHooks(hookName) {
+		const allTxns = [];
+		const quote = "createdAt" in this.quote ? this.quote : {
+			...this.quote,
+			quote: this.quote.quote === "" ? 0n : BigInt(this.quote.quote),
+			amount: 0n,
+			createdAt: Date.now()
+		};
+		const quoteContext = {
+			fromASAID: BigInt(this.quote.fromASAID),
+			toASAID: BigInt(this.quote.toASAID),
+			amount: quote.amount,
+			type: this.quote.type,
+			address: quote.address,
+			algodClient: this.algodClient
+		};
+		for (const mw of this.middleware) {
+			if (!await mw.shouldApply(quoteContext) || !mw[hookName]) continue;
+			const suggestedParams = await this.algodClient.getTransactionParams().do();
+			const swapContext = {
+				quote,
+				address: this.address,
+				algodClient: this.algodClient,
+				suggestedParams,
+				fromASAID: BigInt(this.quote.fromASAID),
+				toASAID: BigInt(this.quote.toASAID),
+				signer: this.defaultSigner
+			};
+			const txns = await mw[hookName](swapContext);
+			allTxns.push(...txns);
+		}
+		return allTxns;
+	}
+	/**
+	* Extract the actual output amount from the confirmed output transaction's inner transactions
+	*
+	* Analyzes only the output transaction (last app call in the swap) to find the
+	* inner transaction that transfers the output asset to the user.
+	*/
+	async extractActualOutputAmount() {
+		if (!this.summaryData?.outputTxnId) return;
+		const outputAssetId = this.summaryData.outputAssetId;
+		const userAddress = this.address;
+		try {
+			const innerTxns = (await this.algodClient.pendingTransactionInformation(this.summaryData.outputTxnId).do()).innerTxns;
+			if (!innerTxns) return;
+			for (const innerTxn of innerTxns) {
+				const txn = innerTxn.txn.txn;
+				const payment = txn.payment;
+				const assetTransfer = txn.assetTransfer;
+				const receiver = payment?.receiver ?? assetTransfer?.receiver;
+				if (!receiver) continue;
+				if (receiver.toString() !== userAddress) continue;
+				const senderAddress = txn.sender.toString();
+				if (outputAssetId === 0n && payment?.amount != null) {
+					this.summaryData.outputAmount = payment.amount;
+					this.summaryData.outputSender = senderAddress;
+				} else if (outputAssetId !== 0n && assetTransfer) {
+					if (assetTransfer.assetIndex === outputAssetId && assetTransfer.amount != null) {
+						this.summaryData.outputAmount = assetTransfer.amount;
+						this.summaryData.outputSender = senderAddress;
+					}
+				}
+			}
+		} catch {}
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/**
+* HTTP error with status code and response data
+*/
+var HTTPError = class extends Error {
+	constructor(status, statusText, data) {
+		super(`HTTP ${status} ${statusText}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.data = data;
+		this.name = "HTTPError";
+	}
+};
+/**
+* Make an HTTP request and parse JSON response
+*
+* Simple wrapper around native fetch for API calls. Throws HTTPError for
+* non-2xx responses.
+*
+* @param url - The URL to request
+* @param options - Fetch options
+* @returns Parsed JSON response
+* @throws HTTPError if the response status is not ok
+*/
+async function request(url, options) {
+	const response = await fetch(url, options);
+	if (!response.ok) {
+		let errorData;
+		try {
+			errorData = await response.json();
+		} catch {
+			try {
+				errorData = await response.text();
+			} catch {
+				errorData = "Failed to parse error response";
+			}
+		}
+		throw new HTTPError(response.status, response.statusText, JSON.stringify(errorData));
+	}
+	return response.json();
+}
+
+//#endregion
+//#region src/client.ts
+/**
+* Client for interacting with the Haystack order router API
+*
+* The RouterClient provides methods to fetch swap quotes and create transaction composers
+* for executing swaps on the Algorand blockchain. It handles API communication, transaction
+* validation, and automatic asset/app opt-in detection.
+*
+* @example
+* ```typescript
+* const router = new RouterClient({
+*   apiKey: 'your-api-key',
+* })
+* ```
+*
+* @example
+* ```typescript
+* const router = new RouterClient({
+*   apiKey: 'your-api-key',
+*   apiBaseUrl: 'https://hayrouter.txnlab.dev',
+*   algodUri: 'https://mainnet-api.4160.nodely.dev/',
+*   algodToken: '',
+*   algodPort: 443,
+*   referrerAddress: 'REFERRER_ADDRESS...',
+*   feeBps: 15,
+*   autoOptIn: false,
+* })
+* ```
+*/
+var RouterClient = class {
+	config;
+	algodClient;
+	middleware;
+	/**
+	* Create a new RouterClient instance
+	*
+	* @param config - Configuration parameters
+	* @param config.apiKey - API key for Haystack Router API (required)
+	* @param config.apiBaseUrl - Base URL for the Haystack Router API (default: https://hayrouter.txnlab.dev)
+	* @param config.algodUri - Algod node URI (default: https://mainnet-api.4160.nodely.dev/)
+	* @param config.algodToken - Algod node token (default: '')
+	* @param config.algodPort - Algod node port (default: 443)
+	* @param config.referrerAddress - Referrer address for fee sharing (receives 25% of swap fees)
+	* @param config.feeBps - Fee in basis points (default: 15 = 0.15%, max: 300 = 3.00%)
+	* @param config.autoOptIn - Automatically detect and add required opt-in transactions (default: false)
+	* @param config.debugLevel - Debug logging level (default: 'none')
+	* @param config.middleware - Array of middleware to apply to swaps (default: [])
+	*/
+	constructor(config) {
+		const debugLevel = config.debugLevel ?? DEFAULT_DEBUG_LEVEL;
+		Logger.setLevel(debugLevel);
+		this.config = {
+			apiKey: this.validateApiKey(config.apiKey),
+			apiBaseUrl: config.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+			algodUri: config.algodUri ?? DEFAULT_ALGOD_URI,
+			algodToken: config.algodToken ?? DEFAULT_ALGOD_TOKEN,
+			algodPort: config.algodPort ?? DEFAULT_ALGOD_PORT,
+			referrerAddress: config.referrerAddress ? this.validateAddress(config.referrerAddress) : void 0,
+			feeBps: this.validateFeeBps(config.feeBps ?? DEFAULT_FEE_BPS),
+			autoOptIn: config.autoOptIn ?? DEFAULT_AUTO_OPT_IN,
+			debugLevel
+		};
+		this.algodClient = new Algodv2(this.config.algodToken, this.config.algodUri, this.config.algodPort);
+		this.middleware = config.middleware ?? [];
+	}
+	/**
+	* Fetch a swap quote from the Haystack Router API
+	*
+	* Requests optimal swap routing from the Haystack Router API. The quote includes routing
+	* information, price impact, required opt-ins, and an encrypted transaction payload.
+	*
+	* @param params - Parameters for the quote request
+	* @param params.fromASAID - The ID of the asset to swap from
+	* @param params.toASAID - The ID of the asset to swap to
+	* @param params.amount - The amount of the asset to swap in base units
+	* @param params.type - The type of the quote (default: 'fixed-input')
+	* @param params.disabledProtocols - List of protocols to disable (default: [])
+	* @param params.maxGroupSize - The maximum group size (default: 16)
+	* @param params.maxDepth - The maximum depth (default: 4)
+	* @param params.address - The address of the account that will perform the swap (recommended when using `config.autoOptIn` or `params.optIn`)
+	* @param params.optIn - Whether to include asset opt-in transaction
+	*   - If true: API reduces maxGroupSize by 1 and includes opt-in (always included, even if not needed)
+	*   - If false: No opt-in transaction included
+	*   - If undefined: Falls back to `config.autoOptIn` behavior with account check (if `params.address` is provided)
+	* @returns A FetchQuoteResponse object with routing information
+	*
+	* @example
+	* ```typescript
+	* const quote = await router.fetchQuote({
+	*   address: 'ABC...',
+	*   fromASAID: 0,           // ALGO
+	*   toASAID: 31566704,      // USDC
+	*   amount: 1_000_000,      // 1 ALGO
+	* })
+	* ```
+	*/
+	async fetchQuote(params) {
+		const { fromASAID, toASAID, amount, type = "fixed-input", disabledProtocols = [], maxGroupSize = DEFAULT_MAX_GROUP_SIZE, maxDepth = DEFAULT_MAX_DEPTH, optIn, address, _allowNonComposableSwaps = false } = params;
+		if (_allowNonComposableSwaps && (optIn === true || this.config.autoOptIn)) throw new Error("Cannot use _allowNonComposableSwaps with optIn or autoOptIn. When allowing non-composable swaps (Tinyman v1), you must handle asset opt-ins and opt-outs in separate transaction groups.");
+		const allDisabledProtocols = _allowNonComposableSwaps ? [...new Set(["Humble", ...disabledProtocols])] : [...new Set([...DEPRECATED_PROTOCOLS, ...disabledProtocols])];
+		let includeOptIn = optIn;
+		if (includeOptIn === void 0 && this.config.autoOptIn) if (address) includeOptIn = await this.needsAssetOptIn(this.validateAddress(address), toASAID);
+		else console.warn("autoOptIn is enabled but no address provided to fetchQuote(). Asset opt-in check skipped.");
+		const url = new URL(`${this.config.apiBaseUrl}/fetchQuote`);
+		url.searchParams.append("apiKey", this.config.apiKey);
+		url.searchParams.append("algodUri", this.config.algodUri);
+		url.searchParams.append("algodToken", this.config.algodToken);
+		url.searchParams.append("algodPort", String(this.config.algodPort));
+		url.searchParams.append("feeBps", this.config.feeBps.toString());
+		url.searchParams.append("fromASAID", BigInt(fromASAID).toString());
+		url.searchParams.append("toASAID", BigInt(toASAID).toString());
+		url.searchParams.append("amount", BigInt(amount).toString());
+		url.searchParams.append("type", type);
+		url.searchParams.append("disabledProtocols", allDisabledProtocols.join(","));
+		url.searchParams.append("maxGroupSize", maxGroupSize.toString());
+		url.searchParams.append("maxDepth", maxDepth.toString());
+		if (typeof includeOptIn === "boolean") url.searchParams.append("optIn", String(includeOptIn));
+		if (this.config.referrerAddress) url.searchParams.append("referrerAddress", this.config.referrerAddress);
+		return request(url.toString());
+	}
+	/**
+	* Check if asset opt-in is required for the output asset
+	*
+	* Convenience method to determine if an address needs to opt into the output asset
+	* of a swap. This is useful when you want to get a quote without requiring wallet
+	* connection upfront, but need to know whether to set `optIn: true` in fetchQuote()
+	* to ensure proper routing (as opt-ins reduce maxGroupSize by 1).
+	*
+	* Note: If you enable `config.autoOptIn`, this check is handled automatically when
+	* an address is provided to fetchQuote().
+	*
+	* @param address - The address to check
+	* @param assetId - The output asset ID to check
+	* @returns True if asset opt-in is required, false otherwise (always false for ALGO)
+	*
+	* @example
+	* ```typescript
+	* // Check if opt-in needed for output asset before fetching quote
+	* const needsOptIn = await router.needsAssetOptIn(userAddress, toAssetId)
+	* const quote = await router.fetchQuote({
+	*   fromAssetId,
+	*   toAssetId,
+	*   amount,
+	*   optIn: needsOptIn,
+	* })
+	* ```
+	*/
+	async needsAssetOptIn(address, assetId) {
+		const accountInfo = await this.algodClient.accountInformation(address).do();
+		return BigInt(assetId) !== 0n && accountInfo?.assets?.find((asset) => asset.assetId === BigInt(assetId)) === void 0;
+	}
+	/**
+	* Fetch swap transactions from the Haystack Router API
+	*
+	* Decrypts the quote payload and generates executable swap transactions for the
+	* specified signer address with the given slippage tolerance.
+	*
+	* @param params - Parameters for the swap transaction request
+	* @param params.quote - The quote response from fetchQuote()
+	* @param params.address - The address of the signer
+	* @param params.slippage - The slippage tolerance as a percentage (e.g., 1 for 1%)
+	* @returns A FetchSwapTxnsResponse object with transaction data
+	*/
+	async fetchSwapTransactions(params) {
+		const { quote, address, slippage } = params;
+		this.validateAddress(address);
+		const url = new URL(`${this.config.apiBaseUrl}/fetchExecuteSwapTxns`);
+		const body = {
+			apiKey: this.config.apiKey,
+			address,
+			txnPayloadJSON: quote.txnPayload,
+			slippage
+		};
+		return request(url.toString(), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	/**
+	* Fetch a quote and return an enhanced quote result
+	*
+	* This is the recommended way to fetch quotes. It returns an object that
+	* extends the raw API response with additional metadata and type normalization.
+	*
+	* @param params - Parameters for the quote request
+	* @param params.fromASAID - The ID of the asset to swap from
+	* @param params.toASAID - The ID of the asset to swap to
+	* @param params.amount - The amount of the asset to swap in base units
+	* @param params.type - The type of the quote (default: 'fixed-input')
+	* @param params.disabledProtocols - List of protocols to disable (default: [])
+	* @param params.maxGroupSize - The maximum group size (default: 16)
+	* @param params.maxDepth - The maximum depth (default: 4)
+	* @param params.address - The address of the account that will perform the swap (recommended when using `config.autoOptIn` or `params.optIn`)
+	* @param params.optIn - Whether to include asset opt-in transaction
+	* @returns A SwapQuote enhanced quote result
+	*
+	* @example
+	* ```typescript
+	* const quote = await router.newQuote({
+	*   address: 'ABC...',
+	*   fromASAID: 0,
+	*   toASAID: 31566704,
+	*   amount: 1_000_000,
+	* })
+	*
+	* console.log(quote.quote)     // bigint - quoted amount
+	* console.log(quote.fromASAID) // number - input asset ID
+	* console.log(quote.toASAID)   // number - output asset ID
+	* console.log(quote.amount)    // bigint - original request amount
+	* console.log(quote.createdAt) // number - timestamp
+	* ```
+	*/
+	async newQuote(params) {
+		if (params._allowNonComposableSwaps) throw new Error("The _allowNonComposableSwaps parameter is not supported with newQuote(). This parameter is only available with fetchQuote() for advanced use cases. The newQuote() method is designed for composable swaps with middleware support.");
+		let adjustedParams = { ...params };
+		const quoteContext = {
+			fromASAID: BigInt(params.fromASAID),
+			toASAID: BigInt(params.toASAID),
+			amount: BigInt(params.amount),
+			type: params.type ?? "fixed-input",
+			address: params.address ?? void 0,
+			algodClient: this.algodClient
+		};
+		for (const mw of this.middleware) if (await mw.shouldApply(quoteContext) && mw.adjustQuoteParams) adjustedParams = await mw.adjustQuoteParams(adjustedParams);
+		const response = await this.fetchQuote(adjustedParams);
+		return {
+			...response,
+			quote: response.quote === "" ? 0n : BigInt(response.quote),
+			amount: BigInt(params.amount),
+			address: params.address ?? void 0,
+			createdAt: Date.now()
+		};
+	}
+	/**
+	* Create a SwapComposer instance
+	*
+	* This factory method creates a composer that allows you to add custom transactions
+	* before and after the swap transactions, with automatic handling of pre-signed transactions
+	* and opt-ins.
+	*
+	* @param config.quote - The quote result from newQuote() or raw API response from fetchQuote()
+	* @param config.address - The address of the signer
+	* @param config.slippage - The slippage tolerance
+	* @param config.signer - Transaction signer function
+	* @returns A SwapComposer instance ready for building transaction groups
+	*
+	* @example
+	* ```typescript
+	* // Basic swap
+	* const quote = await router.newQuote({ ... })
+	* await router.newSwap({ quote, address, slippage, signer })
+	*   .execute()
+	* ```
+	*
+	* @example
+	* ```typescript
+	* // Advanced swap with custom transactions
+	* const quote = await router.newQuote({ ... })
+	* const swap = await router.newSwap({
+	*   quote,
+	*   address,
+	*   slippage,
+	*   signer,
+	* })
+	*
+	* console.log(swap.getStatus()) // BUILDING
+	*
+	* const signedTxns = await swap
+	*   .addTransaction(beforeTxn)
+	*   .addSwapTransactions() // Adds swap transactions to the group
+	*   .addTransaction(afterTxn)
+	*   .sign()
+	*
+	* console.log(swap.getStatus()) // SIGNED
+	*
+	* const result = await swap.execute(waitRounds)
+	* console.log(result.confirmedRound, result.txIds)
+	*
+	* console.log(swap.getStatus()) // COMMITTED
+	* ```
+	*/
+	async newSwap(config) {
+		const { quote, address, slippage, signer, note } = config;
+		return new SwapComposer({
+			quote,
+			swapTxns: (await this.fetchSwapTransactions({
+				quote,
+				address,
+				slippage
+			})).txns,
+			algodClient: this.algodClient,
+			address,
+			signer,
+			middleware: this.middleware,
+			note,
+			debugLevel: this.config.debugLevel
+		});
+	}
+	/**
+	* Validates the API key
+	*/
+	validateApiKey(apiKey) {
+		if (!apiKey) throw new Error("API key is required");
+		return apiKey;
+	}
+	/**
+	* Validates an Algorand address
+	*/
+	validateAddress(address) {
+		if (!isValidAddress(address)) throw new Error(`Invalid Algorand address: ${address}`);
+		return address;
+	}
+	/**
+	* Validates the fee in basis points (max 300 = 3.00%)
+	*/
+	validateFeeBps(feeBps) {
+		if (feeBps < 0 || feeBps > MAX_FEE_BPS) throw new Error(`Invalid fee: ${feeBps} basis points (must be between 0 and ${MAX_FEE_BPS})`);
+		return feeBps;
+	}
+};
+
+//#endregion
+//#region src/middleware.ts
+/**
+* Middleware that automatically adds an asset opt-out transaction when swapping
+* the full balance of an input asset, leaving it with a zero balance.
+*
+* @example
+* ```typescript
+* import { RouterClient, AutoOptOutMiddleware } from '@txnlab/haystack-router'
+*
+* const autoOptOut = new AutoOptOutMiddleware({
+*   excludedAssets: [31566704], // Don't auto-opt-out of USDC
+* })
+*
+* const router = new RouterClient({
+*   apiKey: 'your-api-key',
+*   middleware: [autoOptOut],
+* })
+*
+* // When swapping full balance, opt-out transaction is automatically added
+* const quote = await router.newQuote({
+*   address: userAddress,
+*   fromASAID: someAssetId,
+*   toASAID: 0,
+*   amount: fullBalance, // If this equals account's full balance, opt-out is added
+*   type: 'fixed-input',
+* })
+* ```
+*/
+var AutoOptOutMiddleware = class {
+	name = "AutoOptOut";
+	version = "1.0.0";
+	excludedAssets;
+	constructor(config = {}) {
+		this.excludedAssets = new Set((config.excludedAssets ?? []).map((id) => BigInt(id)));
+	}
+	async shouldApply(context) {
+		if (context.type !== "fixed-input") return false;
+		if (!context.address) return false;
+		if (context.fromASAID === 0n) return false;
+		if (this.excludedAssets.has(context.fromASAID)) return false;
+		try {
+			const assetHolding = (await context.algodClient.accountInformation(context.address).do()).assets?.find((asset) => asset.assetId === context.fromASAID);
+			if (!assetHolding) return false;
+			return assetHolding.amount === context.amount;
+		} catch (error) {
+			console.warn(`AutoOptOutMiddleware: Failed to fetch account info for ${context.address}:`, error);
+			return false;
+		}
+	}
+	async adjustQuoteParams(params) {
+		const maxGroupSize = (params.maxGroupSize ?? 16) - 1;
+		return {
+			...params,
+			maxGroupSize
+		};
+	}
+	async afterSwap(context) {
+		return [{
+			txn: makeAssetTransferTxnWithSuggestedParamsFromObject({
+				sender: context.address,
+				receiver: context.address,
+				amount: 0n,
+				assetIndex: context.fromASAID,
+				closeRemainderTo: context.address,
+				suggestedParams: context.suggestedParams
+			}),
+			signer: context.signer
+		}];
+	}
+};
+
+//#endregion
+export { AutoOptOutMiddleware, DEFAULT_ALGOD_PORT, DEFAULT_ALGOD_TOKEN, DEFAULT_ALGOD_URI, DEFAULT_API_BASE_URL, DEFAULT_AUTO_OPT_IN, DEFAULT_CONFIRMATION_ROUNDS, DEFAULT_DEBUG_LEVEL, DEFAULT_FEE_BPS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_GROUP_SIZE, DEPRECATED_PROTOCOLS, HTTPError, MAX_FEE_BPS, Protocol, RouterClient, SwapComposer, SwapComposerStatus, request };
+//# sourceMappingURL=index.mjs.map